当前位置：首页 > news >正文

CAS、CAS自旋、CAS自旋锁、CLH锁与Java AQS：深入理解并发编程核心机制

news 来源：原创 2025/5/9 8:34:48

CAS、CAS自旋、CAS自旋锁、CLH锁与Java AQS：深入理解并发编程核心机制

1. CAS（Compare and Swap）

什么是CAS？

CAS（Compare and Swap）是一种无锁（Lock-Free）的原子操作，用于在多线程环境下实现数据同步。其核心思想是：

比较内存中的值与预期值是否一致，若一致则更新为新值，否则不修改。
整个过程是原子的，由底层硬件（如CPU的CMPXCHG指令）直接支持。

CAS在Java中的实现

Java通过Unsafe类和原子类（如AtomicInteger）提供CAS支持：

public class AtomicInteger {public final boolean compareAndSet(int expect, int update) {return unsafe.compareAndSwapInt(this, valueOffset, expect, update);}
}

示例：

AtomicInteger count = new AtomicInteger(0);
count.compareAndSet(0, 1); // 成功将0改为1

CAS的优缺点

优点：
- 避免锁竞争，减少线程切换开销。
- 适用于低冲突场景（如计数器、标志位更新）。
缺点：
- ABA问题：值从A→B→A，CAS无法感知中间变化。
  解决方案：使用版本号（如AtomicStampedReference）。
- 自旋开销：长时间失败可能导致CPU空转。

2. CAS自旋与CAS自旋锁

CAS自旋（Spin）

CAS自旋是指线程在CAS失败后循环重试，直到成功。
示例：实现一个简单的自增操作：

public class SpinCounter {private AtomicInteger value = new AtomicInteger(0);public void increment() {int oldVal;do {oldVal = value.get();} while (!value.compareAndSet(oldVal, oldVal + 1));}
}

CAS自旋锁（Spin Lock）

基于CAS自旋实现的锁，线程在获取锁失败时不会阻塞，而是循环尝试。
示例：

public class SpinLock {private AtomicBoolean locked = new AtomicBoolean(false);public void lock() {while (!locked.compareAndSet(false, true)) {// 自旋等待}}public void unlock() {locked.set(false);}
}

缺点：

高竞争下CPU利用率高，适用于临界区极短的场景（如操作系统内核）。

3. CLH锁

CLH锁的设计思想

CLH（Craig, Landin, Hagersten）锁是一种基于链表的队列锁，通过隐式队列管理线程，减少缓存一致性流量。

核心结构：每个线程持有一个节点（Node），包含一个volatile布尔字段locked。
加锁流程：
1. 线程创建一个节点，locked设为true。
2. 将前驱节点的locked字段作为自旋条件。
3. 当前驱节点释放锁（locked=false），当前线程获取锁。

CLH锁的Java伪代码

public class CLHLock {private static class Node {volatile boolean locked = true;}private final ThreadLocal<Node> myNode = ThreadLocal.withInitial(Node::new);private final AtomicReference<Node> tail = new AtomicReference<>();public void lock() {Node node = myNode.get();Node pred = tail.getAndSet(node);while (pred != null && pred.locked) {// 自旋等待前驱节点释放锁}}public void unlock() {myNode.get().locked = false;myNode.remove(); // 清理线程本地状态}
}

CLH锁的优势

公平性：严格按请求顺序获取锁。
低缓存一致性开销：线程仅监视前驱节点的状态，减少总线风暴。

4. Java AQS（AbstractQueuedSynchronizer）

AQS的核心设计

AQS是Java并发包（java.util.concurrent）的核心框架，用于构建锁和同步器（如ReentrantLock、Semaphore）。

核心思想：
- 通过一个volatile int state表示同步状态（如锁的重入次数、信号量许可数）。
- 使用CLH变体的双向队列（FIFO）管理等待线程。

AQS的模板方法模式

AQS提供需子类实现的抽象方法（如tryAcquire、tryRelease），开发者只需关注状态管理逻辑。
示例：实现一个独占锁：

public class SimpleLock extends AbstractQueuedSynchronizer {@Overrideprotected boolean tryAcquire(int arg) {return compareAndSetState(0, 1); // 通过CAS获取锁}@Overrideprotected boolean tryRelease(int arg) {setState(0); // 释放锁return true;}public void lock() {acquire(1);}public void unlock() {release(1);}
}

AQS的同步队列

队列节点（Node）：
每个节点保存线程引用、等待状态（如CANCELLED、SIGNAL）和前驱/后继指针。
入队与出队：
- 线程获取锁失败时，被包装为Node加入队列尾部。
- 前驱节点释放锁后，唤醒后继节点。

AQS与CLH锁的关系

AQS的同步队列是CLH锁的变体：

将CLH的隐式队列改为显式的双向链表。
支持中断、超时和条件变量（Condition）。

5. 对比总结

机制	特点	适用场景
CAS	无锁原子操作，依赖硬件指令	简单状态更新（如计数器）
CAS自旋锁	基于CAS的自旋，无队列管理	临界区极短，低竞争环境
CLH锁	公平锁，基于隐式队列，减少缓存一致性流量	高并发公平锁需求
AQS	提供同步框架，支持独占/共享模式、条件变量	构建复杂同步器（如ReentrantLock）