【并发】Java锁分类

本文总结了Java并发领域的锁分类,包括乐观锁/悲观锁、显式锁/隐式锁、独享锁/共享锁、互斥锁/读写锁、公平锁/非公平锁、偏向锁/轻量级锁/重量级锁、可重入锁、分段锁和自旋锁。详细阐述了各类锁的工作原理和应用场景,帮助读者深入理解Java并发编程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

在Java并发领域,根据锁的状态、特性、粒度、轻重等有不同的分类方法,很多并发书籍或者文章都会或多或少提及一些专有的锁名词,为了理解各种分类的分类方法、原理及作用,在此特意总结一下。

 

一、乐观锁/悲观锁

乐观锁:

乐观地认为对于同一个数据来说不会被其他线程修改,因此不会加锁。更新数据的时候,借助冲突检查机制来判断更新过程中是否存在来自其他线程的干扰,存在则操作失败,并且可以重试。

乐观锁常见的形式就是“无锁”,常采用CAS(Compare and Swap)算法,典型例子是Atomic包下的原子类,通过CAS自旋达到原子操作的程度来实现同步。

悲观锁:

悲观地认为对于同一个数据来说一定会被其它线程修改,因此必须上锁。

悲观锁常见的形式就是各种锁如synchronized内置锁、ReentranLock等。

 

二、显式锁/隐式锁

显式锁:

显示锁就是对于需要上锁的代码块需要显式上锁,如lock.lock(),退出同步代码块的时候也需要显式解锁,如lock.unlock()。

最常见的就是实现了Lock接口的各种锁如ReentranLock。

隐式锁:

隐式锁就是不需要显式上锁,由虚拟机自动加锁。

最常见的就是synchronized关键字。

 

三、独享锁/共享锁

独享锁:

在同一时间只能由同一线程所持有。

常见的实现Synchronized、ReentrantLock等。

共享锁:

在同一时间内可被多个线程所持有。

常见的实现是ReadWriteLock,其读锁是共享锁,写锁则是独享锁,对于并发读的情况效率很高。

 

四、互斥锁/读写锁

互斥锁:

互斥锁就是独享锁的具体实现。

具体实现跟独享锁一致。

读写锁:

读写锁就是共享锁的具体实现。

具体实现跟共享锁一致。

 

五、公平锁/非公平锁

公平锁:

公平锁指的是多个线程按照申请锁的顺序来获取锁。

具体实现由ReentrantLock,默认是非公平锁,但可以通过构造函数指定为公平锁,通过AQS来实现线程调度变成公平锁。

非公平锁:

非公平锁指的是多个线程并非按照申请锁的顺序来获取锁,可能是根据优先级顺序。采用非公平锁可能会发生优先级反转或者饥饿现象,即某一线程一直等待得不到该锁。非公平锁的优点在于吞吐量较公平锁大。

具体实现有ReentrantLock默认实现及synchronized关键字。

 

六、偏向锁/轻量级锁/重量级锁

这三种锁指的是锁的状态,且都是针对sychronized内置锁的。jdk1.6中引入锁升级机制来提高synchronized内置锁的效率。

偏向锁:

偏向锁会偏向于第一个获得它的线程,如果在接下来的执行过程中,该锁没有被其他线程获取,则持有偏向锁的线程永远不需要再进行同步。偏向锁可以提高带有同步但无竞争的程序性能。

轻量级锁:

当另外一个线程尝试获取另外一个线程曾经所占有的偏向锁时,这个锁就会升级为轻量级锁。

重量级锁:

重量级锁就是传统的采用系统互斥量实现的锁,也可以由轻量级锁升级而来:当一个线程持有轻量级锁,另外一个线程想要获取该锁时会发生自旋等待,当自旋到一定次数时,如果还没有获取到该锁的话,该线程就会阻塞,同时轻量级锁升级为重量级锁。

 

七、可重入锁

可重入锁指的是同一线程在外层方法获取锁的时候,内层方法也会自动获得锁,可重入锁可以一定程度上避免死锁。

常见的实现由synchornized内置锁。

 

八、分段锁

分段锁指的是对于同一段数据,将其分为多个段,每一段加一个分段锁,这样并发操作该数据时,只要不是同一段内的数据都可以实现并发操作。

具体的实现就是ConcurrentHashMap中就采用了分段锁,每一个数据段称为一个Segment,在对数据进行操作的时候,只要通过hashcode来判断该数据处于哪一个Segment,就对该Segment上锁并操作该段数据,同时不会影响其他Segment的数据操作。

但是在统计size或其他全局信息的时候,就要获取所有的分段锁才能统计,因此适用于获取size需求不那么大的场景。

 

九、自旋锁

自旋锁指的是当一个线程尝试获取锁的时候不会立即阻塞,而是循环尝试获取该锁,这种方式在大部分线程操作都是轻量级的情况下能显著提高效率,减少了线程上下文切换的消耗,但是如果在自旋期间始终获取不到该锁的话就只能白白消耗CPU资源。

<think>我们正在讨论Java并发编程中的分类。根据用户提供的引用和之前讨论的内容,我们可以将Java中的进行多维度分类分类可以从以下几个角度进行: 1. 按的性质:乐观 vs 悲观 2. 按的获取方式:显式 vs 隐式 3. 按的状态升级:无 -> 偏向 -> 轻量级 -> 重量级(仅synchronized) 4. 按的行为:可重入 vs 不可重入 5. 按共享策略:独占 vs 共享 6. 按的公平性:公平 vs 非公平 7. 按的优化技术:分段 下面我们根据这些分类详细展开,并给出每种的示例和特点。</think>### Java 并发编程中的分类详解 Java 并发可从**性质**、**实现方式**、**行为特性**和**优化策略**四个维度分类,核心分类如下: --- #### 一、按性质分类 | **类型** | **代表实现** | **特点** | **适用场景** | |----------------|---------------------|--------------------------------------------------------------------------|---------------------------| | **悲观** | `synchronized`、`ReentrantLock` | 默认并发冲突高,操作前先加(阻塞其他线程) | 写多读少、强一致性场景 | | **乐观** | `StampedLock`(乐观读) | 默认无冲突,通过版本号(如 `stamp`)检测冲突,失败则重试或升级为悲观[^4] | 读多写少、弱一致性场景 | > 💡 **示例:乐观实现** > ```java > StampedLock lock = new StampedLock(); > // 乐观读(不阻塞写线程) > long stamp = lock.tryOptimisticRead(); > if (!lock.validate(stamp)) { // 检查版本 > stamp = lock.readLock(); // 冲突则升级为悲观读 > try { /* 读取数据 */ } > finally { lock.unlockRead(stamp); } > } > ``` --- #### 二、按实现方式分类 | **类型** | **代表实现** | **特点** | |----------------|-----------------------|--------------------------------------------------------------------------| | **隐式** | `synchronized` | JVM 自动管理加/释放(通过字节码指令 `monitorenter`/`monitorexit`)[^3] | | **显式** | `ReentrantLock`、`StampedLock` | 需手动调用 `lock()`/`unlock()`,支持更灵活的控制(如超时、中断)[^1] | > ⚠️ **显式注意事项**: > - 必须用 `try-finally` 确保释放(避免死) > - `StampedLock` **不支持重入**,设计不当易导致死[^2] --- #### 三、按行为特性分类 | **类型** | **代表实现** | **特点** | |------------------|---------------------------|--------------------------------------------------------------------------| | **可重入** | `synchronized`、`ReentrantLock` | 同一线程可重复获取同一把(避免自死) | | **不可重入** | `StampedLock` | 同一线程重复获取会阻塞(需谨慎设计逻辑)[^2] | | **公平** | `ReentrantLock(true)` | 按线程等待顺序分配(避免饥饿,但性能低) | | **非公平** | `synchronized`、`ReentrantLock()` | 允许插队(默认模式,吞吐量高) | | **读写分离** | `ReentrantReadWriteLock` | 读共享(允许多线程并发读),写独占 | > 📊 **性能对比**: > ``` > 读操作性能:StampedLock(乐观读) > ReentrantReadWriteLock > synchronized > 写操作性能:ReentrantLock ≈ synchronized > StampedLock > ``` --- #### 四、按优化策略分类 | **策略** | **实现方式** | **目的** | |------------------|-----------------------------------|------------------------------------------| | **升级** | `synchronized` 的偏向→轻量级→重量级 | 根据竞争强度动态调整粒度[^3] | | **分段** | `ConcurrentHashMap` 的分段 | 将大对象拆分为小段,降低竞争[^3] | | **粗化** | JIT 编译器优化 | 合并连续加操作,减少请求次数[^3] | | **消除** | JIT 编译器优化(逃逸分析) | 移除不可能存在竞争的(如局部变量) | > 🔧 **分段示例**: > ```java > ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(); > // 不同段(如不同key)可并行操作 > map.computeIfAbsent("key1", k -> 1); // 段1加 > map.computeIfAbsent("key2", k -> 2); // 段2加(并行执行) > ``` --- ### 总结:选择指南 1. **优先隐式**:简单同步场景用 `synchronized`(JVM 自动优化升级)[^3] 2. **高并发读**:选 `StampedLock` 或 `ReentrantReadWriteLock`(读多写少场景)[^4] 3. **灵活控制**:需超时/中断功能时用 `ReentrantLock`[^1] 4. **性能极致优化**:结合分段粗化等策略减少竞争[^3] > ⚠️ **避坑提示**: > - `StampedLock` 适合**内部工具类**,复杂业务慎用(易死)[^2] > - 优化需结合性能测试(JMH),避免过度设计 --- ### 附录:状态转换(synchronized 升级) ```mermaid graph LR A[无] -->|首次访问| B[偏向:记录线程ID] B -->|其他线程访问| C[轻量级:CAS自旋] C -->|自旋失败| D[重量级:OS互斥] D -->|释放| A ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值