AQS（ReentrantLock）源码浅析
管程 — Java同步的设计思想
管程：指的是管理共享变量以及对共享变量的操作过程，让他们支持并发。
互斥：同一时刻只允许一个线程访问共享资源；
同步：线程之间如何通信、协作。
MESA模型
在管程的发展史上，先后出现过三种不同的管程模型，分别是Hasen模型、Hoare模型和MESA模型。现在正在广泛使用的是MESA模型。AQS便是对MESA的经典实现。
管程中引入了条件变量的概念，而且每个条件变量都对应有一个等待队列。条件变量和等待队列的作用是解决线程之间的同步问题。
AQS原理分析
什么是AQS
java.util.concurrent包中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这些行为的抽象就是基于AbstractQueuedSynchronizer（简称AQS）实现的，AQS是一个抽象同步框架，可以用来实现一个依赖状态的同步器。
JDK中提供的大多数的同步器如Lock, Latch, Barrier等，都是基于AQS框架来实现的
- 一般是通过一个内部类Sync继承 AQS
- 将同步器所有调用都映射到Sync对应的方法
AQS具备哪些特性？
- 阻塞等待队列
- 共享/独占
- 公平/非公平
- 可重入
- 允许中断
AQS两种队列
- 同步等待队列： 主要用于维护获取锁失败时入队的线程。
- 条件等待队列： 调用await()的时候会释放锁，然后线程会加入到条件队列，调用signal()唤醒的时候会把条件队列中的线程节点移动到同步队列中，等待再次获得锁。
AQS队列中的节点包含5种状态
- 值为0，初始化状态，表示当前节点在sync队列中，等待着获取锁。
- CANCELLED，值为1，表示当前的线程被取消（如因超时、中断等原因放弃等待锁）；
- SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，也就是unpark；
- CONDITION，值为-2，表示当前节点在等待condition，也就是在condition队中；
- PROPAGATE，值为-3，表示当前场景下后续的acquireShared能够得以执行；
ReentrantLock为独占锁，同一时刻只有一个线程能持有锁，释放锁时，只需唤醒同步队列中的下一个有效节点（通过
unparkSuccessor()），无需传播唤醒信号，因此不存在PROPAGATE。
同步等待队列
AQS当中的同步等待队列也称CLH队列，CLH队列是Craig、Landin、Hagersten三人发明的一种基于双向链表数据结构的队列，是FIFO先进先出线程等待队列，Java中的CLH队列是原CLH队列的一个变种，线程由原自旋机制改为阻塞机制。
AQS 依赖CLH同步队列来完成同步状态的管理：
- 当前线程如果获取同步状态失败时，AQS则会将当前线程以及等待状态等信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程
- 当同步状态释放时，会把首节点唤醒（公平锁），使其再次尝试获取同步状态。
- 通过signal或signalAll将条件队列中的节点转移到同步队列。（由条件队列转化为同步队列）
条件等待队列
AQS中条件队列是使用单向列表保存的，用nextWaiter来连接:
- 调用await方法阻塞线程；
- 当前线程存在于同步队列的头结点，调用await方法进行阻塞（从同步队列转化到条件队列）
public class ConditionDemo {
private static final ReentrantLock lock = new ReentrantLock();
private static final Condition condition = lock.newCondition();
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
lock.lock();
try {
// 让线程在condition上一直等待下去
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "t1").start();
new Thread(() -> {
lock.lock();
try {
// 让线程在condition上一直等待下去
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "t2").start();
// 主线程两秒后执行
Thread.sleep(2000);
log.debug("准备获取锁，去唤醒 condition上阻塞的线程");
lock.lock();
try {
// 唤醒condition上所有阻塞的线程
condition.signalAll();
log.debug("唤醒condition上阻塞的线程");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
结合ReentrantLock浅析AQS源码
重入锁默认使用非公平锁，以下以公平锁为例解析流程
一、加锁
final void lock() {
//通过CAS设置state，成功则当前线程独占锁资源
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
二、尝试获取锁，失败则加入同步等待队列
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
三、公平锁：尝试获取锁。
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//需要遵循先来后到，存在前继节点则不参与竞争
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//当前线程独占锁，重入次数增加
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
四、尾插节点，以及节点状态变更逻辑
private Node addWaiter(Node mode) {
//当前线程node节点
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) {
//尾插到链表末端，并cas设置新的tail
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//自旋+cas重复上面的尾插
enq(node);
return node;
}
//核心接口
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
//node前继节点为头节点，则再次尝试获取锁
if (p == head && tryAcquire(arg)) {
//获取锁成功，设置node为头节点
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//检查更新前继节点状态(p.waitStatus)，返回true阻塞当前node
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
//在整个acquire流程中，此方法是主要的控制waitStatus的地方
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
if (ws > 0) {
//跳过cancel状态的node
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
//前继节点为0或PROPAGATE,通过CAS设置为-1
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
AQS中的核心关注点
公平和非公平锁，可重入锁是如何实现的
公平锁与非公平锁主要体现在锁竞争的机制上，下面对比两者的核心代码：
公平锁：
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//需要遵循先来后到，存在前继节点则不参与竞争
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//重入锁实现
else if (current == getExclusiveOwnerThread()) {
//当前线程独占锁，重入次数增加
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
非公平锁：
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//其他线程释放了锁，CAS设置state
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//重入锁实现
else if (current == getExclusiveOwnerThread()) {
//当前线程独占锁，重入次数增加
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
//获取锁失败
return false;
}
区别很明显：公平锁竞争需要排队，而非公平锁可直接参与竞争
重入锁的实现：判断获取了锁的线程就是当前线程，则state+1，否则失败
注意：获取锁失败进入等待队列之后，公平锁与非公平锁是一样的
浙公网安备 33010602011771号