锁
- 一、引言:并发世界的秩序守护者
- 二、互斥锁:并发控制的基石
-
- 1. 定义与原理
- 2. 操作系统介入
- 3. 性能特征与适用场景:
- 三、自旋锁:忙等待的性能权衡
-
- 1. 定义与原理
- 2. 用户态操作
- 3. 适用场景
- 四、读写锁:读写分离的并发优化
-
- 1. 定义与原理
- 2. 核心优势
- 3. 潜在问题与解决方案
-
- 写饥饿问题
- 其他注意事项
- 五、可重入锁:递归与嵌套的解决方案
-
- 1. 定义与原理
- 2. 工程价值
- 六、乐观锁与悲观锁:两种哲学思想(深度解析)
-
- 1. 悲观锁 (Pessimistic Locking)
- 2. 乐观锁 (Optimistic Locking)
- 七、锁的高级特性与分类(底层逻辑)
-
- 1. 公平锁 vs 非公平锁
- 2. 分段锁 (Segment Lock)
- 八、锁的底层实现与JVM优化(硬核原理)
-
- 1. 原子操作:硬件层面的基石
- 2. synchronized 的锁升级(锁膨胀)
- 九、死锁:并发编程的噩梦(成因与破解)
-
- 1. 产生死锁的四个必要条件(缺一不可)
- 2. 解决方案
- 十、工程实践中的锁策略(架构思维)
-
- 1. 锁的粒度 (Granularity)
- 2. 减少锁的持有时间
- 3. 锁分离与无锁化
一、引言:并发世界的秩序守护者
- 核心矛盾:计算资源的有限性与并发需求的无限性之间的冲突。
- 锁的本质:一种同步机制,用于在并发环境下协调对共享资源的访问,确保数据一致性。
二、互斥锁:并发控制的基石
1. 定义与原理
- 互斥锁(Mutex)是一种同步原语,提供独占访问机制,确保在任意时刻只有一个线程能持有锁并进入临界区
- 底层实现依赖CPU的原子指令(如x86的LOCK CMPXCHG),通过"测试并设置"(Test-and-Set)的原子操作保证锁状态的修改不可分割
- 典型实现包含两个状态:锁定(locked)和解锁(unlocked),以及等待队列管理被阻塞的线程
2. 操作系统介入
- 当线程尝试获取已被占用的锁时,会发生系统调用(如Linux的futex系统调用)
- 内核调度器将当前线程状态从运行态(TASK_RUNNING)改为睡眠态(TASK_INTERRUPTIBLE)
- 上下文切换过程包括:保存寄存器状态、更新进程描述符、切换地址空间,通常需要数百个CPU周期
- 当锁释放时,内核会唤醒等待队列中的一个线程,触发第二次上下文切换
3. 性能特征与适用场景:
-
适合保护耗时较长的临界区(>1ms),如:
- 文件I/O操作(读写大型文件)
- 数据库事务处理
- 复杂数学计算(矩阵运算、物理模拟)
-
不适用于短临界区,因为上下文切换开销(约5-20μs)可能超过实际工作负载
-
现代实现优化:
- 自旋-等待混合锁(如Linux的mutex先自旋一段时间再休眠)
- 乐观锁策略(通过CAS指令减少锁争用)
-
典型使用示例:
private static final Object lock = new Object();
public void criticalSection() {
synchronized (lock) {
// 访问共享资源
}
}
三、自旋锁:忙等待的性能权衡
1. 定义与原理
自旋锁是一种基于忙等待机制的同步原语。其核心原理是:当线程尝试获取锁时,如果发现锁已被占用,不会立即进入阻塞状态,而是通过一个while循环持续检查锁状态(称为"自旋"),直到锁可用。这一过程完全在用户态完成,不涉及操作系统调度。
2. 用户态操作
自旋锁的实现依赖于CPU提供的原子操作指令,常见的有:
- 测试并设置(Test-and-Set)
- 比较并交换(Compare-and-Swap, CAS)
- 获取并增加(Fetch-and-Add) 这些指令保证了加解锁操作的原子性。例如在x86架构下,可以使用lock cmpxchg指令实现CAS操作。由于不涉及系统调用,自旋锁的性能开销主要来自缓存一致性协议(如MESI协议)带来的总线流量。
3. 适用场景
自旋锁最适合保护执行时间极短的临界区(通常<100个时钟周期)。典型应用场景包括:
-
内核中的中断处理程序
-
多核环境下的短时资源保护
-
无竞争或低竞争场景下的同步 当锁持有时间超过上下文切换时间(通常约1-10μs)时,自旋锁会导致CPU资源浪费。现代操作系统通常采用自适应自旋锁,即先自旋一段时间,若仍未获得锁则转为阻塞状态。
-
性能优化:现代处理器针对自旋锁提供了优化指令:
- PAUSE指令(x86架构)可减少自旋时的功耗
- 内存屏障指令保证多核环境下的可见性
- 退避算法(如指数退避)可降低竞争时的总线争用
四、读写锁:读写分离的并发优化
1. 定义与原理
读写锁(ReadWrite Lock)是一种特殊的同步机制,它将传统的互斥锁分为两种类型:
其核心原理基于以下规则:
- 读写互斥:当有线程持有写锁时,其他线程不能获取读锁或写锁
- 写写互斥:同一时间只允许一个写操作
- 读读共享:多个读操作可以并发执行
例如在Java中的ReentrantReadWriteLock实现就采用了这种机制。
2. 核心优势
读写锁在以下典型场景中能带来显著性能提升:
- 数据库缓存系统(如Redis)
- 配置文件的热加载
- 金融系统的行情数据读取
- 电商平台的商品信息查询
在这些"读多写少"(通常读操作占比超过80%)的场景中,相比传统的互斥锁,读写锁可以:
- 提高系统吞吐量3-5倍
- 降低90%以上的读操作等待时间
- 保持数据一致性
3. 潜在问题与解决方案
写饥饿问题
当系统存在以下情况时可能出现:
解决方案包括:
其他注意事项
现代实现如StampedLock还提供了乐观读等更高级的特性,进一步优化了读写锁的性能。
五、可重入锁:递归与嵌套的解决方案
1. 定义与原理
可重入锁(Reentrant Lock)是一种特殊的同步机制,它允许同一个线程多次获取同一把锁而不会导致死锁。其核心实现原理包括:
- 每次成功获取锁时计数器加1
- 每次释放锁时计数器减1
- 当计数器归零时,锁才真正释放
典型实现示例(伪代码):
class ReentrantLock {
Thread owner = null;
int count = 0;
void lock() {
if (owner == currentThread) {
count++;
} else {
// 实际加锁逻辑
owner = currentThread;
count = 1;
}
}
}
2. 工程价值
可重入锁在复杂系统设计中具有重要价值:
递归调用场景:
public synchronized void recursiveMethod(int n) {
if (n <= 0) return;
// 业务逻辑
recursiveMethod(n–1); // 可重入特性避免死锁
}
方法嵌套场景:
- 外层方法A获取锁
- 内层方法B也需要同一把锁
- 无重入特性会导致死锁
复杂业务逻辑:
- 适用于存在多层调用的业务处理流程
- 保持锁行为可预测的同时简化代码结构
锁粒度控制:
- 允许在保持大粒度锁的情况下实现细粒度操作
- 减少锁竞争带来的性能影响
对比不可重入锁,可重入锁显著提高了代码的安全性和可维护性,是构建可靠并发系统的基础组件。
六、乐观锁与悲观锁:两种哲学思想(深度解析)
这两种锁不仅仅是代码实现的不同,更是对并发冲突概率预判的根本差异。
1. 悲观锁 (Pessimistic Locking)
核心思想: “非礼勿视,非礼勿动”。假设最坏的情况,只要有人动数据,就认为一定会发生冲突。因此,在整个数据处理过程中,必须将资源死死锁住。
- 实现机制:
- 数据库层面:使用 SELECT … FOR UPDATE 或 SELECT … LOCK IN SHARE MODE。这会直接锁定数据库行(甚至可能升级为页锁或表锁),直到事务结束。其他事务必须排队等待。
- Java 层面:synchronized 关键字、ReentrantLock。在进入同步代码块前,必须先获取 Monitor 锁。
- 深度剖析:
- 阻塞与唤醒:当线程A持有锁时,线程B尝试获取锁会进入阻塞状态(BLOCKED)。操作系统需要将线程B挂起,这涉及用户态到内核态的切换(Context Switch),开销巨大。
- 适用性:适合写操作多、冲突频繁的场景(如银行转账、库存扣减)。虽然单次操作成本高,但避免了频繁的冲突重试。
2. 乐观锁 (Optimistic Locking)
核心思想: “先干完活,回头再看有没有人动过”。假设冲突很少发生,因此在读取数据时不加锁,只在提交更新时检查数据是否被修改过。
- 实现机制:
- 版本号机制 (Version):数据库表中增加一个 version 字段。读取数据时同时读取 version 值。更新时执行 UPDATE … SET version = new_version WHERE id = ? AND version = old_version。如果 affected_rows 为 0,说明数据已被修改,更新失败。
- CAS (Compare and Swap):基于 CPU 的原子指令。包含三个操作数:内存位置(V)、预期原值(A)、新值(B)。仅当 V 的值等于 A 时,才将 V 更新为 B,否则不做任何操作。
- 深度剖析:
- ABA 问题:这是 CAS 的经典缺陷。线程1读取值 A,准备更新时发现还是 A,于是执行更新。但可能中间经历了 A -> B -> A 的过程,线程1并不知情。解决方案:引入版本号(如 AtomicStampedReference),不仅比较值,还比较版本戳。
- 自旋开销:如果冲突频繁,线程会陷入不断的重试(自旋),消耗 CPU 资源却做无用功。因此,乐观锁适合读多写少的场景(如点赞数统计、配置中心)。
七、锁的高级特性与分类(底层逻辑)
1. 公平锁 vs 非公平锁
这决定了线程获取锁的“排队规则”。
- 公平锁 (Fair Lock):
- 机制:严格按照线程申请锁的顺序来分配。维护一个等待队列(CLH 队列),新来的线程即使发现锁空闲,如果队列不为空,也必须排队。
- 代价:频繁的线程切换。唤醒一个线程后,它必须从队列头节点获取锁,这导致大量的上下文切换,吞吐量低。
- 非公平锁 (Non-Fair Lock):
- 机制:允许“插队”。锁释放时,不仅唤醒队列头节点的线程,新来的线程也可以尝试抢占。如果新线程运气好抢到了,队列里的线程就得继续等。
- 优势:吞吐量高。因为唤醒队列中的线程需要时间,而非公平锁允许新线程利用这段微小的“空窗期”直接执行,减少了 CPU 空转。
- 风险:可能导致队列中的线程长时间无法获取锁(饥饿)。
2. 分段锁 (Segment Lock)
这是一种设计思想,旨在通过锁粒度的细化来提升并发度。
- 原理:将数据结构分成多个段(Segment),每个段独立加锁。
- 经典案例:ConcurrentHashMap (JDK 1.7):
- 它将哈希表分成 16 个 Segment(类似小的 HashMap)。
- 线程 A 操作 Segment 1,线程 B 操作 Segment 2,两者互不干扰。
- 并发度:理论上可以同时支持 16 个线程并发写入(默认并发级别为 16)。
- 演变:JDK 1.8 后,ConcurrentHashMap 放弃了分段锁,改用 CAS + synchronized 修饰链表头/红黑树根节点,粒度更细,效率更高。
八、锁的底层实现与JVM优化(硬核原理)
1. 原子操作:硬件层面的基石
所有的锁机制最终都依赖于 CPU 提供的原子指令。
- CAS (Compare and Swap):这是无锁并发的基础。在 x86 架构下,它通过 cmpxchg 指令实现。
- 内存屏障 (Memory Barrier):为了防止指令重排序导致的数据不一致,JVM 在关键位置插入内存屏障(如 StoreLoad Barriers),强制刷新 CPU 缓存,保证可见性。
2. synchronized 的锁升级(锁膨胀)
JVM 为了减少 synchronized 的性能开销,设计了一套极其复杂的优化机制,锁的状态会随着竞争激烈程度逐步升级:
- 场景:只有一个线程访问同步块(如单线程遍历 Vector)。
- 机制:JVM 会把对象头(Mark Word)中标记为“偏向模式”,并记录该线程的 ID。下次同一个线程进入同步块时,不需要任何 CAS 操作,直接进入。这消除了无竞争情况下的同步开销。
- 场景:存在多个线程,但它们交替执行同步块,没有竞争(如线程A执行完,线程B再执行)。
- 机制:线程在自己的栈帧中建立锁记录(Lock Record),通过 CAS 将对象头指向该记录。如果成功则获取锁,失败则说明有竞争,升级为重量级锁。
- 场景:多线程竞争激烈。
- 机制:此时 JVM 向操作系统申请互斥量(Mutex)。线程会进入内核态阻塞,需要操作系统调度唤醒。这是最慢的,但能保证在激烈竞争下的正确性。
九、死锁:并发编程的噩梦(成因与破解)
死锁是两个或多个线程互相持有对方需要的资源,并无限期等待对方释放的现象。
1. 产生死锁的四个必要条件(缺一不可)
2. 解决方案
- 预防(破坏条件):
- 破坏循环等待:给资源编号(Resource Ordering)。所有线程必须按照编号顺序申请资源。例如,先申请编号 1 的锁,再申请编号 2 的锁,绝不允许反过来。
- 避免(银行家算法):
- 在分配资源前,先判断此次分配是否会导致系统进入“不安全状态”。如果是,则让线程等待。
- 检测与恢复:
- Jstack:允许死锁发生,通过工具(如 jstack)定期检测死锁线程。
- 超时机制:使用 tryLock(timeout),如果在规定时间内未获取到锁,则放弃当前操作并释放已持有的资源,稍后重试。
十、工程实践中的锁策略(架构思维)
在实际开发中,使用锁不仅仅是加个关键字那么简单,更是一门权衡的艺术。
1. 锁的粒度 (Granularity)
- 粗粒度锁:用一把大锁保护一大片资源(如 Hashtable)。优点是简单,缺点是并发度低。
- 细粒度锁:用多把小锁分别保护不同的资源(如 ConcurrentHashMap)。优点是并发度高,缺点是代码复杂,容易引发死锁。
- 策略:根据业务热点决定。如果是热点账户,锁粒度要细;如果是普通业务,适当粗粒度以减少锁管理开销。
2. 减少锁的持有时间
- 原则:临界区代码越短越好。
- 技巧:将非核心的、耗时的操作(如 I/O、复杂的计算、网络请求)移出同步代码块。
- 错误做法:在 synchronized 块里调用 Thread.sleep() 或远程 HTTP 接口。
- 正确做法:在锁内只做共享变量的读写,获取数据后立即释放锁,再进行后续处理。
3. 锁分离与无锁化
- 读写锁分离:使用 ReentrantReadWriteLock。读操作不互斥,写操作互斥。极大提升读多写少场景的性能。
- 无锁数据结构:优先使用 java.util.concurrent 包下的原子类(AtomicInteger)或并发容器(ConcurrentLinkedQueue),它们基于 CAS 实现,性能通常优于加锁。
- ThreadLocal:如果可能,将共享变量变为线程私有变量,从根本上消除竞争。



