架构视界
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
  • 标签索引
  • 2024年

    • 勇闯大A:美债与美元周期
    • 勇闯大A:交易纪律与自我管理
    • 勇闯大A:交易系统分层
    • 勇闯大A:买卖点与止损规则
    • 勇闯大A:债券与资金流向
    • 勇闯大A:微观、宏观与周期
    • Mac 开发环境:新机配置清单
    • 勇闯大A:内外盘与换手率
    • 会计管理:财报阅读与管理报表
    • 会计基础:记账原理与分录
    • 财务入门:财务体系全景
  • 2023年

    • 境外投资:泰国 BOI 申请实务
  • 2022年

    • 企业架构:故障管理与分级响应
    • 企业架构:技术债务的识别、度量与偿还
  • 2021年

    • Python 数据分析:员工分布可视化
    • Python 数据分析:IP 访问折线图
    • Python 数据分析:IP 词云图
    • Redis:RediSearch 全文检索
    • Rust 基础:第一个 CLI 程序
    • Rust 基础:所有权机制
    • Rust 基础:函数与控制流
    • Rust 基础:变量与数据类型
    • Rust 基础:入门与开发环境
    • 企业架构:分布式系统设计
    • 企业架构:编程式权限设计
    • JVM 调优:启动参数与 GC 日志
    • MyBatis 批量插入:三种写法对比
    • 测试:Spring Boot 分层 Mock
    • Redis:布隆过滤器判断元素存在
    • Jenkins:安装配置与应用部署
    • WebClient:非阻塞 HTTP 客户端
    • Drone:Docker 部署轻量 CI
    • Spring AOP:操作审计日志落库
    • Redisson:分布式锁与 RedLock
    • MyBatis 拦截器:雪花算法主键
    • Netty:线程模型与网络编程
    • Redis:SCAN 游标遍历大键空间
    • Jenkins:单机部署与升级脚本
    • Mac:Neo4j 与 Jupyter 安装
    • JavaFX:OpenJDK 11 环境配置
    • Mac:用 jenv 管理 JDK 版本
    • Redis:有序集合实现延时队列
    • Spring Boot 日志:MDC 串联链路
    • 定时任务:Spring 调度与 Cron
    • GoAccess:Nginx 日志分析
    • MyBatis 拦截器:慢 SQL 分析
    • Lucene:倒排索引与中文分词
    • 分布式锁:三种实现方案对比
    • 学习技巧:减少学习排斥心理
    • 动态数据源:多租户数据路由
    • Compose:Spring Boot 三件套
    • Java 阻塞队列:源码与用法
    • Redis:Docker Compose 哨兵
    • Redis:Docker Compose 主从
    • 网络通信:TCP/IP 与 HTTP 基础
  • 2020年

    • 延时队列:DelayQueue 与 Redis 实现
    • MySQL 基础:员工库导入实践
    • 雪花算法:分布式 ID 生成
    • Redis:地理位置查询
    • 抓包:Wireshark 与 Tcpdump
    • SPI:JDK 与 Spring 扩展机制
    • ZooKeeper:概念与集群搭建
    • Spring Boot:集成 JMH 基准测试
    • Wireshark:抓包工具入门
    • Compose:Redis 与 MySQL
    • CentOS 7:Docker 安装部署
    • Netty:源码阅读环境搭建
    • MySQL 基础:SQL 常见用法
    • CentOS 7:Selenium 运行环境
    • Nginx:HTTPS 证书配置
    • JMH:基准测试与 Spring Boot 集成
    • Spring Boot:指定 Tomcat 版本
    • Eureka:实例上下线告警
    • 钉钉告警:应用异常与实例上下线
    • JVM:内存布局、类加载与调优
    • Git:rebase 合并多次提交
    • CentOS 7:OpenResty 部署
  • 2019年

    • Redis CLI:macOS 安装与使用
    • Nginx:访问日志格式
    • 工程规范:可维护代码的写法
    • IntelliJ IDEA:常用插件
    • SkyWalking:源码阅读环境搭建
    • Spring Boot:Redis 超时配置
    • gRPC:ProtoBuf 定义与代码生成
    • Arthas:Java 线上问题诊断
    • Redis:缓存穿透与击穿防护
    • Docker 部署:Elasticsearch
    • Docker 部署:MySQL 5.7 单机
    • Spring Redis:字符串命令封装
    • Docker 部署:ZooKeeper 运行
    • Docker 部署:Redis 单机运行
    • Dubbo:Spring Boot 微服务集成
    • CentOS 7:CMake 源码编译安装
    • 性能度量:吞吐量与 QPS 指标
    • Java 递归:从笔试题到经典问题
    • CentOS 7:ELK 日志平台部署
    • CentOS 7:SonarQube 部署
    • Selenium:Chrome 浏览器自动化
    • JJWT:令牌生成与解析测试
    • Spring 源码:阅读环境搭建
    • JUnit 4:注解、断言与参数化
    • JWT:令牌结构与签名机制
    • FastDFS:架构与文件存取机制
    • XPath:XML 文档节点定位
    • Redis 基础:锁、队列与事务
    • Redis 基础:数据类型与命令
    • MyBatis:Slf4j 日志接入
    • MyBatis:H2 单元测试与 SQL 日志
    • 源码阅读:开源项目环境搭建
    • Git 配置:命令清单与作用域
    • Java 核心:面向对象与基础类型
    • Java 核心:关键字、异常与反射
    • Java 核心:多线程基础
    • Java 核心:同步关键字与线程池
    • Java 核心:锁与并发工具
    • Java 核心:语言基础与并发
    • Dubbo:远程调用与服务治理
    • Java 集合:框架总览与实现对比
    • Maven:生命周期与常用命令
    • MyBatis:执行流程与插件机制
    • Spring:IoC 容器与依赖注入
    • Spring:AOP 与自动装配
    • Spring:事务与启动流程
    • Spring:IoC、AOP 与事务
    • Spring MVC:请求分发与注解
    • MySQL:架构与索引
    • MySQL:事务、锁与 MVCC
    • MySQL:日志与 SQL 优化
    • MySQL:架构、事务与优化
    • Redis 基础:持久化与线程模型
  • 2018年

    • Java HashMap:扩容机制与哈希冲突
    • Java 集合:HashSet 去重原理
    • Java 基础:交换两个变量的值
    • Spring MVC:零 web.xml 改造
    • Mac 开发环境:新机配置清单
    • Log4j:日志分级与按业务拆分
    • Modbus:工业通信协议与 RTU 帧
    • MySQL 基础:子查询与连接查询
    • MySQL 基础:库与表操作
    • MySQL 基础:表操作与查询
    • MySQL 基础:约束、引擎与数据类型
    • MySQL 基础:库表、约束与类型
    • Java 集合:Vector 与 Stack
    • Java 集合:Vector 与 Stack
    • RabbitMQ:CentOS 7 单机部署
    • Redis:CentOS 7 单机部署
    • MongoDB:CentOS 7 单机部署
    • Linux:常用系统与运维命令
    • 注册中心:Eureka 与 ZooKeeper
    • MySQL:CentOS 7 单机部署
    • Git 分支:主分支与临时分支
    • CentOS 7:Java 开发环境部署
    • Java 集合:LinkedList 双向链表
    • Java 集合:ArrayList 动态数组
    • Spring AOP:注解方式实现切面
← 返回博客

Java 核心:锁与并发工具

2019年1月1日 #后端开发 #Java

系列文章:Java 核心:语言基础与并发 的第 5 篇。

Lock

Lock对象也可以实现同步,在使用上更加方便。

Java多线程中,可以使用synchronized关键字来实现线程之间同步互斥,但是再jdk1.5以后增加了ReentrantLock类。并且功能更加强大、灵活。

锁名称应用
乐观锁CAS
自旋锁CAS
悲观锁synchronized、vector、hashtable
可重入锁synchronized、Reentrantlock、Lock
读写锁ReentrantReadWriteLock,CopyOnWriteArrayList、CopyOnWriteArraySet
公平锁Reentrantlock(true)
非公平锁synchronized、reentrantlock(false)
共享锁ReentrantReadWriteLock中读锁
独占锁synchronized、vector、hashtable、ReentrantReadWriteLock中写锁
重量级锁synchronized
互斥锁synchronized
同步锁synchronized
分段锁concurrentHashMap
死锁相互请求对方的资源
锁粗化锁优化技术
锁消除锁优化技术
轻量级锁锁优化技术
偏向锁锁优化技术

AQS-AbstractQueuedSynchronizer

AQS:AbstractQueuedSynchronizer 抽象队列同步器

内部实现了一个FIFO列队来管理锁,线程会首先尝试获取锁,如果失败。则将当前线程以及等待信息包装成一个node节点放入同步列队中柱塞,当有锁的线程释放锁的时候,则会唤醒列队中的等待的线程。

  • AQS 这里只定义了一个接口,具体资源的获取交由自定义同步器去实现了(通过 state 的 get/set/CAS)之所以没有定义成abstract ,是因为独占模式下只用实现 tryAcquire-tryRelease ,而共享模式下只用实现tryAcquireShared-tryReleaseShared。如果都定义成abstract,那么每个模式也要去实现另一模式下的接口。不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可,至于具体线程等待队列的维护(如获取资源失败入队/唤醒出队等)。

  • AQS定义类一个

LockSupport

是用来创建锁和其他同步类的基本线程阻塞原语。

CountDownLatch

CounttDownLatch 是 java.util.concurrent(JUC)中的锁,闭锁。利用它可以实现类似计数器的功能。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。

案例

 @Test
    public void oneTest() {
        // 计数器10 state = 10
        int total = 10;
        CountDownLatch countDownLatch = new CountDownLatch(total);
        for (int i = 0; i < total; i++) {
            new Thread(() -> {
                log.info("running");
                countDownLatch.countDown();
            }).start();
        }
        try {
            log.info("await");
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

输出

14:22:53.775 [main] INFO cn.z201.java.test.aqs.CountDownLatchTest - await
14:22:53.775 [Thread-7] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-1] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-5] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-8] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-2] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-9] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-4] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-6] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-0] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-3] INFO cn.z201.java.test.aqs.CountDownLatchTest - running

ReentrantLock

ReentrantLock 是 java.util.concurrent(J.U.C)包中的锁。和synchronized也是互斥锁,同时可以实现公平和非公平锁。

构造方法


//默认非公平锁
public ReentrantLock() {
     sync = new NonfairSync();
}

//传入true,可以构建公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

案例

public class LockExample {

    private Lock lock = new ReentrantLock();

    public void func() {
        lock.lock();
        try {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        } finally {
            lock.unlock(); // 确保释放锁,从而避免发生死锁。
        }
    }
}
public static void main(String[] args) {
    LockExample lockExample = new LockExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> lockExample.func());
    executorService.execute(() -> lockExample.func());
}
// 最后输出 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
public class ReentrantLockDemo {

    private Lock lock = new ReentrantLock();

    public void test(){
        // 调用ReentrantLock的lock方法获取锁
        lock.lock();
        for (int i = 0; i < 3; i++) {
            System.out.println("ThreadName " + Thread.currentThread().getName() + " number " + i);
        }
        // 调用ReentrantLock的lock方法释放锁
        lock.unlock();
    }
}

public class ReentrantLockThread extends Thread{
    private ReentrantLockDemo reentrantLockDemo;

    public ReentrantLockThread(ReentrantLockDemo reentrantLockDemo) {
        this.reentrantLockDemo = reentrantLockDemo;
    }

    @Override
    public void run() {
        reentrantLockDemo.test();
    }
}

public class ReentrantLockTests {

    public static void main(String[] args) {
        ReentrantLockDemo reentrantLockDemo = new ReentrantLockDemo();
        ReentrantLockThread reentrantLockThread1 = new ReentrantLockThread(reentrantLockDemo);
        ReentrantLockThread reentrantLockThread2 = new ReentrantLockThread(reentrantLockDemo);
        ReentrantLockThread reentrantLockThread3 = new ReentrantLockThread(reentrantLockDemo);
        ReentrantLockThread reentrantLockThread4 = new ReentrantLockThread(reentrantLockDemo);
        reentrantLockThread1.start();
        reentrantLockThread2.start();
        reentrantLockThread3.start();
        reentrantLockThread4.start();
    }

}

输出结果

ThreadName Thread-0 number 0
ThreadName Thread-0 number 1
ThreadName Thread-0 number 2
ThreadName Thread-2 number 0
ThreadName Thread-2 number 1
ThreadName Thread-2 number 2
ThreadName Thread-3 number 0
ThreadName Thread-3 number 1
ThreadName Thread-3 number 2
ThreadName Thread-1 number 0
ThreadName Thread-1 number 1
ThreadName Thread-1 number 2
  • 当前的线程执行完成之后才能执行其他线程,但是其他线程执行的顺序是随机的。

ReentrantReadWriteLock

ReentrantReadWriteLock锁 实际也是继承了AQS类来实现锁的功能的

案例

@Slf4j
public class ReentrantReadWriteLockTest {

    private final Map<String,String> data = new HashMap<>();
    /**
     * 读、写锁
     */
    private final ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    /**
     * 读锁
     */
    private final Lock readLock = reentrantReadWriteLock.readLock();

    /**
     * 写锁
     */
    private final Lock writeLock = reentrantReadWriteLock.writeLock();

    @Test
    public void test(){
        put("a","a");
        get("a");
    }

    public String get(String key){
        readLock.lock();
        log.info("读锁");
        try {
            return data.get(key);
        }finally {
            readLock.unlock();
        }
    }

    public String put(String key ,String value){
        writeLock.lock();
        log.info("写锁");
        try {
            return data.put(key,value);
        }finally {
            writeLock.unlock();
        }
    }


}

输出

00:25:27.321 [main] INFO cn.z201.java.test.lock.ReentrantReadWriteLockTest - 写锁
00:25:27.325 [main] INFO cn.z201.java.test.lock.ReentrantReadWriteLockTest - 读锁

Semaphore

java.util.concurrent(JUC) ,Semaphore翻译成字面意思为 信号量,Semaphore可以控同时访问的线程个数,通过 acquire() 获取一个许可,如果没有就等待,而 release() 释放一个许可。

案例

这里防止主线程终止,先睡个10s。

    @Test
    public void oneTest() throws InterruptedException {
        int total = 10;
        Semaphore semaphore = new Semaphore(5);
        for (int i = 0; i < total; i++) {
            new Thread(new SemaphoreRunnable(semaphore)).start();
        }
        Thread.sleep(10000);
        log.info("info");
    }

    public static class SemaphoreRunnable implements Runnable {

        private Semaphore semaphore;

        public SemaphoreRunnable(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                log.info("{} acquire",Thread.currentThread().getName());
                semaphore.acquire();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //释放信号量
                log.info("{} release ",Thread.currentThread().getName());
                semaphore.release();
            }
        }
    }

输出

14:10:08.873 [Thread-6] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-6 acquire
14:10:08.874 [Thread-9] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-9 acquire
14:10:08.874 [Thread-5] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-5 acquire
14:10:08.874 [Thread-7] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-7 acquire
14:10:08.874 [Thread-2] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-2 acquire
14:10:08.874 [Thread-4] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-4 acquire
14:10:08.874 [Thread-0] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-0 acquire
14:10:08.874 [Thread-1] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-1 acquire
14:10:08.874 [Thread-8] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-8 acquire
14:10:08.874 [Thread-3] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-3 acquire
14:10:09.884 [Thread-5] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-5 release 
14:10:09.884 [Thread-7] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-7 release 
14:10:09.884 [Thread-9] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-9 release 
14:10:09.884 [Thread-2] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-2 release 
14:10:09.884 [Thread-6] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-6 release 
14:10:10.885 [Thread-4] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-4 release 
14:10:10.885 [Thread-1] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-1 release 
14:10:10.885 [Thread-0] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-0 release 
14:10:10.886 [Thread-8] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-8 release 
14:10:10.886 [Thread-3] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-3 release 
14:10:18.877 [main] INFO cn.z201.java.test.aqs.SemaphoreTest - info

CyclicBarrier

CyclicBarrier 是 java.util.concurrent(JUC)中的锁,栅栏锁。它可以实现让一组线程等待至某个状态之后再全部同时执行。

案例

 @Test
    public void oneTest() {
        int total = 5;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(total);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < total; i++) {
            executorService.execute(() -> {
                log.info("await");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException
                        | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                log.info("running");
            });
        }
    }

输出

15:06:17.233 [pool-1-thread-4] INFO cn.z201.java.test.aqs.CyclicBarrierTest - await
15:06:17.233 [pool-1-thread-3] INFO cn.z201.java.test.aqs.CyclicBarrierTest - await
15:06:17.233 [pool-1-thread-2] INFO cn.z201.java.test.aqs.CyclicBarrierTest - await
15:06:17.233 [pool-1-thread-5] INFO cn.z201.java.test.aqs.CyclicBarrierTest - await
15:06:17.233 [pool-1-thread-1] INFO cn.z201.java.test.aqs.CyclicBarrierTest - await
15:06:17.233 [main] INFO cn.z201.java.test.aqs.CyclicBarrierTest - main
15:06:17.239 [pool-1-thread-1] INFO cn.z201.java.test.aqs.CyclicBarrierTest - running
15:06:17.239 [pool-1-thread-2] INFO cn.z201.java.test.aqs.CyclicBarrierTest - running
15:06:17.239 [pool-1-thread-5] INFO cn.z201.java.test.aqs.CyclicBarrierTest - running
15:06:17.239 [pool-1-thread-3] INFO cn.z201.java.test.aqs.CyclicBarrierTest - running
15:06:17.239 [pool-1-thread-4] INFO cn.z201.java.test.aqs.CyclicBarrierTest - running

Condition

synchronized 关键字,它配合 Object 的 wait()、notify() 系列方法可以实现等待/通知模式。对于 Lock,通过 Condition 也可以实现等待/通知模式。Condition 是一个接口。Condition 接口的实现类是 Lock(AQS)中的 ConditionObject。Lock 接口中有个 newCondition() 方法,通过这个方法可以获得 Condition 对象(其实就是 ConditionObject )。因此,通过 Lock 对象可以获得 Condition 对象。

Lock lock  = new ReentrantLock();
Condition ondition1 = lock.newCondition();
Condition condition2 = lock.newCondition();

CountDownLatch与CyclicBarrier

  • CountDownLatch的作用是允许1或N个线程等待其他线程完成执行;而CyclicBarrier则是允许N个线程相互等待
  • CountDownLatch的计数器无法被重置;CyclicBarrier的计数器可以被重置后使用,因此它被称为是循环的barrier

CAS Compare-And-Swap

CAS的全称是Compare-And-Swap,它是CPU并发原语。它的功能是判断内存某个位置的值是否为预期值,如果是则更改为新的值,这个过程是原子的,可用于在多线程编程中实现不被打断的数据交换操作,从而避免多线程同时改写某一数据时由于执行顺序不确定性以及中断的不可预知性产生的数据不一致问题。该操作通过将内存中的值与指定数据进行比较,当数值一样时将内存中的数据替换为新的值。其原理是利用sun.misc.Unsafe.java 类通过JNI来调用硬件级别的原子操作来实现CAS(即CAS是借助C来调用CPU底层指令实现的)。

  • CAS = 比较并交换 + 乐观版本锁 + 锁自旋

  • CAS具备原子性,它是cpu硬件指令实现保证原子性。通过JNI调用Native方法由c++编写的硬件级别指令。JDK中通过Unsafe类执行操作。

  • 非阻塞算法
  • 非独占锁

ABA问题

CAS 算法实现一个重要前提需要取出内存中某时刻的数据,而在下时刻比较并替换,那么在这个时间差类会导致数据的变化。

  • 比如说一个线程 t1 从内存位置 V 中取出 A,这时候另一个线程 t2 也从内存中取出 A,并且t2 进行了一些操作变成了 B,然后 t2 又将 V 位置的数据变成 A,这时候线程 t1 进行 CAS 操作发现内存中仍然是 A,然后 t1 操作成功。此时CAS比较值相等,自旋成功。
  • 部分乐观锁的实现是通过版本号(version)的方式来解决 ABA 问题,乐观锁每次在执行数据的修改操作时,都会带上一个版本号,一旦版本号和数据的版本号一致就可以执行修改操作并对版本号执行+1 操作,否则就执行失败。因为每次操作的版本号都会随之增加,所以不会出现 ABA 问题,因为版本号只会增加不会减少。

synchronized和ReentrantLock 的区别

  • 两者都是可重⼊锁

    • 两者都是可重⼊锁。“可重⼊锁”概念是:⾃⼰可以再次获取⾃⼰的内部锁。⽐如⼀个线程获得了某个对象的锁,此时这个对象锁还没有释放,当其再次想要获取这个对象的锁的时候还是可以获取的,如果不可锁重⼊的话,就会造成死锁。同⼀个线程每次获取锁,锁的计数器都⾃增1,所以要等到锁的计数器下降为0时才能释放锁。
  • synchronized 依赖于 JVM ⽽ ReentrantLock 依赖于 API

    • synchronized 是依赖于 JVM 实现的,前⾯我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进⾏了很多优化,但是这些优化都是在虚拟机层⾯实现的,并没有直接暴露给我们。ReentrantLock 是 JDK 层⾯实现的(也就是 API 层⾯,需要 lock() 和 unlock() ⽅法配合try/finally 语句块来完成),所以我们可以通过查看它的源代码,来看它是如何实现的。
  • synchronized的方式加锁,会让线程在 BLOCKED 状态和 RUNNABLE 状态之间切换,在操作系统上,就会造成用户态和内核态的频繁切换,效率就比较低。

  • 相⽐synchronized,ReentrantLock增加了⼀些⾼级功能

    除非需要使用 ReentrantLock 的高级功能,否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制,JVM 原生地支持它,而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题,因为 JVM 会确保锁的释放。

    • 等待可中断

      • ReentrantLock提供了⼀种能够中断等待锁的线程的机制,通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待,改为处理其他事情。
    • 实现公平锁

      • ReentrantLock可以指定是公平锁还是⾮公平锁。⽽synchronized只能是⾮公平锁。所谓的公平锁就是先等待的线程先获得锁。 ReentrantLock默认情况是⾮公平的,可以通过 ReentrantLock类的 ReentrantLock(boolean fair) 构造⽅法来制定是否是公平的。
    • 可实现选择性通知

      • ReentrantLock类实现等待/通知机制,需要借助于Condition接⼝与newCondition() ⽅法。Condition是JDK1.5之后才有的,它具有很好的灵活性,⽐如可以实现多路通知功能也就是在⼀个Lock对象中可以创建多个Condition实例(即对象监视器),线程对象可以注册在指定的Condition中,从⽽可以有选择性的进⾏线程通知,在调度线程上更加灵活。 在使⽤notify()/notifyAll()⽅法进⾏通知时,被通知的线程是由 JVM 选择的,⽤ReentrantLock类结合Condition实例可以实现**“选择性通知”** ,这个功能⾮常重要,⽽且是Condition接⼝默认提供的。⽽synchronized关键字就相当于整个Lock对象中只有⼀个Condition实例,所有的线程都注册在它⼀个身上。如果执⾏notifyAll()⽅法的话就会通知所有处于等待状态的线程这样会造成很⼤的效率问题,⽽Condition实例的signalAll()⽅法 只会唤醒注册在该Condition实例中的所有等待线程。

公平锁/非公平锁

公平读写锁比较简单的一种方式是:用队列把获取锁的线程排队,不管是写线程还是读线程都按照先进先出的原则加锁即可,这样读线程仍然可以并发,也不会出现「饥饿」的现象。

  • 公平锁的含义是线程需要按照请求的顺序来获得锁;而非公平锁则允许“插队”的情况存在,所谓的“插队”指的是,线程在发送请求的同时该锁的状态恰好变成了可用,那么此线程就可以跳过队列中所有排队的线程直接拥有该锁。
  • 而公平锁由于有挂起和恢复所以存在一定的开销,因此性能不如非公平锁,所以 ReentrantLock 和 synchronized 默认都是非公平锁的实现方式。

可重入锁

  • 可重入锁又名递归锁,是指在同一个线程,在外层方法获取锁的时候,在进入内层方法会自动获取锁**。**
  • 可重入锁的一个好处是可一定程度避免死锁。

共享锁/独占锁

  • 只能被单线程持有的锁叫独占锁,可以被多线程持有的锁叫共享锁。

    • 独占锁指的是在任何时候最多只能有一个线程持有该锁,比如 synchronized 就是独占锁,而 ReadWriteLock 读写锁允许同一时间内有多个线程进行读操作,它就属于共享锁。
    • 独占锁可以理解为悲观锁,当每次访问资源时都要加上互斥锁,而共享锁可以理解为乐观锁,它放宽了加锁的条件,允许多线程同时访问该资源。
  • 共享锁是指锁可被多个线程所持有。如果一个线程对数据加上共享锁后,那么其他线程只能对数据再加共享锁,不能加独占锁。获得共享锁的线程只能读数据,不能修改数据。

    • 在 JDK 中 ReentrantReadWriteLock 就是一种共享锁。

互斥锁/读写锁

  • 上面讲的独享锁/共享锁就是一种广义的说法,互斥锁/读写锁就是具体的实现。
    • 互斥锁在Java中的具体实现就是ReentrantLock
    • 读写锁在Java中的具体实现就是ReadWriteLock

分段锁

  • 分段锁其实是一种锁的设计,并不是具体的一种锁,对于ConcurrentHashMap而言,其并发的实现就是通过分段锁的形式来实现高效的并发操作。

锁升级(无锁|偏向锁|轻量级锁|重量级锁)

  • 无锁状态其实就是上面讲的乐观锁。

  • 偏向锁是指一段同步代码一直被一个线程所访问,那么该线程会自动获取锁。降低获取锁的代价。

    • 当锁对象第一次被线程获取的时候,虚拟机将会把对象头中的标志位设为“01” (可偏向),即偏向模式。同时使用CAS操作把获取到这个锁的线程的ID记录在对象的Mark Word之中,如果CAS操作成功,持有偏向锁的线程以后每次进入这个锁相关的同步块时,虚拟机都可以不再进行任何同步操作。
    • 当有另外一个线程去尝试获取这个锁时,偏向模式就宣告结束。根据锁对象目前是否处于被锁定的状态,撤销偏向(Revoke Bias)后恢复到未锁定(标志位为“01”,不可偏向)或 轻量级锁定(标志位为“00”)的状态,后续的同步操作就进入轻量级锁的流程。
  • 进入到轻量级锁说明不止一个线程尝试获取锁,这个阶段会通过自适应自旋CAS方式获取锁。如果获取失败,则进行锁膨胀,进入重量级锁流程,线程阻塞。

  • 重量级锁是通过系统的线程互斥锁来实现的,代价最昂贵

自旋锁

  • 自旋锁是指线程在没有获得锁时不是被直接挂起,而是执行一个忙循环,这个忙循环就是所谓的自旋。
    • 如果锁被另一个线程占用的时间比较长,即使自旋了之后当前线程还是会被挂起,忙循环就会变成浪费系统资源的操作,反而降低了整体性能。因此自旋锁是不适应锁占用时间长的并发情况的。

互斥锁与自旋锁

  • 互斥锁加锁失败后,线程会释放 CPU ,给其他线程;
    • 互斥锁是一种「独占锁」,比如当线程 A 加锁成功后,此时互斥锁已经被线程 A 独占了,只要线程 A 没有释放手中的锁,线程 B 加锁就会失败,于是就会释放 CPU 让给其他线程,既然线程 B 释放掉了 CPU,自然线程 B 加锁的代码就会被阻塞。
      • 对于互斥锁加锁失败而阻塞的现象,是由操作系统内核实现的。当加锁失败时,内核会将线程置为「睡眠」状态,等到锁被释放后,内核会在合适的时机唤醒线程,当这个线程成功获取到锁后,于是就可以继续执行。
  • 自旋锁加锁失败后,线程会忙等待,直到它拿到锁;
    • 自旋锁是通过 CPU 提供的 CAS 函数(Compare And Swap),在「用户态」完成加锁和解锁操作,不会主动产生线程上下文切换,所以相比互斥锁来说,会快一些,开销也小一些。
    • 一般加锁的过程,包含两个步骤:
      • 第一步,查看锁的状态,如果锁是空闲的,则执行第二步;
      • 第二步,将锁设置为当前线程持有;
      • CAS 函数就把这两个步骤合并成一条硬件级指令,形成原子指令,这样就保证了这两个步骤是不可分割的,要么一次性执行完两个步骤,要么两个步骤都不执行。
      • 使用自旋锁的时候,当发生多线程竞争锁的情况,加锁失败的线程会「忙等待」,直到它拿到锁。

锁优化技术(锁粗化|锁消除)

  • 锁粗化就是将多个同步块的数量减少,并将单个同步块的作用范围扩大,本质上就是将多次上锁、解锁的请求合并为一次同步请求。
  • 锁消除是指虚拟机编译器在运行时检测到了共享数据没有竞争的锁,从而将这些锁进行消除。

死锁(Deadlock)?如何分析和避免死锁?

  • 死锁是指两个以上的线程永远阻塞的情况,这种情况产生至少需要两个以上的线程和两个以上的资源。
  • 分析死锁,我们需要查看Java应用程序的线程转储。我们需要找出那些状态为BLOCKED的线程和他们等待的资源。每个资源都有一个唯一的id,用这个id我们可以找出哪些线程已经拥有了它的对象锁。
  • 避免嵌套锁,只在需要的地方使用锁和避免无限期等待是避免死锁的通常办法。

案例

@Slf4j
public class DeadLockTest {

    public static void main(String[] args) {
        Object l1 = new Object();
        Object l2 = new Object();
        new Thread(()->{
            synchronized (l1){
                log.info("{} lock 1 success",Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (l2){
                    log.info("{} lock 2 success",Thread.currentThread().getName());
                }

            }
        }).start();

        new Thread(()->{
            synchronized (l2){
                log.info("{} lock 2 success",Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (l1){
                    log.info("{} lock 1 success",Thread.currentThread().getName());
                }
            }
        }).start();
    }
}

14:53:28.122 [Thread-1] INFO cn.z201.java.test.lock.DeadLockTest - Thread-1 lock 2 success
14:53:28.122 [Thread-0] INFO cn.z201.java.test.lock.DeadLockTest - Thread-0 lock 1 success

如何避免线程死锁

  • 破坏互斥条件 :这个条件我们没有办法破坏,因为我们⽤锁本来就是想让他们互斥的(临界资源需要互斥访问)。

  • 破坏请求与保持条件 :⼀次性申请所有的资源。

  • 破坏不剥夺条件 :占⽤部分资源的线程进⼀步申请其他资源时,如果申请不到,可以主动释放它占有的资源。

  • 破坏循环等待条件 :靠按序申请资源来预防。按某⼀顺序申请资源,释放资源则反序释放。破坏循环等待条件。

Java中常见的线程同步方式

  • Object中wait\notify\notifyAll完成对monitor之间的同步。
  • synchronized对方法\对象代码块同步。
  • volatile关键字修饰字段实现变量的可见性。
  • atomic自增自减。
  • ThreadLoacal线程局部变量。
  • juc包下工具类\LinkedBlockingQueue。
  • Thread中join\await方法实现任务顺序执行。

相关规范

  • JVM规范
    • Java语言规范、Java虚拟机规范、Java内存模型规范。
    • JSR规范。
    • IETF规范。

小结

AQS 以 state 加等待队列支撑 ReentrantLock、Semaphore 与 CountDownLatch;读写锁分离读写并发,CAS 免阻塞但需处理 ABA,死锁靠固定加锁顺序与超时规避。

最近更新: 2026/11/20 22:35
Contributors: 庆峰
Prev
Java 核心:同步关键字与线程池
Next
Java 核心:语言基础与并发