java.util.concurrent包系列文章
JUC—ThreadLocal源码解析(JDK13)
JUC—ThreadPoolExecutor线程池源码解析(JDK13)
JUC—各种锁(JDK13)
JUC—原子类Atomic*.java源码解析(JDK13)
JUC—CAS源码解析(JDK13)
JUC—ConcurrentHashMap源码解析(JDK13)
JUC—CopyOnWriteArrayList源码解析(JDK13)
JUC—并发队列源码解析(JDK13)
JUC—多线程下控制并发流程(JDK13)
JUC—AbstractQueuedSynchronizer解析(JDK13)
本篇是JUC系列的最后一篇，有请最最神秘的AbstractQueuedSynchronizer—AQS。它是众多并发工具的基石。是一个用于构建锁，同步器，线程协作工具类的框架。
一、AQS
AQS是JDK1.5加入的一个基于FIFO等待队列实现的一个用于实现同步器的基础框架。
前面几篇文章展示了ReentrantLock，ReentrantReadWriteLock，Semaphore，CountDownLatch等线程协作类的使用。他们的底层都是基于AQS的。AQS就是一个支持并发的工具类。抽象出了一些支持并发需要的共同属性和方法。在它基础之上的各种并发类的实现只要根据自己的需要去编写自己特有的并发逻辑。
AQS的实现类，很多熟悉的身影
看看代码
Semaphore
ReentrantLock
它们有个共同点是都有个Sync内部类继承自AbstractQueuedSynchronizer，拥有了AQS的方法。
二、AQS的三核心
AQS的核心有三
- 1、并发肯定会有需要竞争的某个资源，那就包括这个资源的同步状态的原子性管理。state属性
- 2、并发肯定会有队列来放等待的线程。FIFO队列
- 3、既然需要线程挂起等待，那肯定需要线程的阻塞与解除阻塞。需要实现类去实现的获取/释放方法
结合图看一下，三大核心
state
/**
* The synchronization state.
*/
// state是volatile修饰的
private volatile int state;
state的具体含义在不同的实现类中有不同的意义。
- 在Semaphore中代表剩余的信号量，一个线程拿走一个信号量state就减一，释放一个就加一。
- 在CountDownLatch中代表还要倒数的数量。
- 在ReentrantLock中代表锁的占有情况，有线程获取到锁state为1，没有任何线程持有锁，state为0。如果是可重入进来的锁，state+1。
对state的操作必须保证线程安全，一共2个方法可以改变state的值
// 这个方法只有在初始化才会调用
protected final void setState(int newState) {
state = newState;
}
// CAS保证操作原子性
protected final boolean compareAndSetState(int expect, int update) {
return STATE.compareAndSet(this, expect, update);
}
FIFO队列
这个队列用来存放“等待的线程”，AQS就是排队管理器。当锁释放时，就挑选一个合适的线程来占有这个释放的锁。
head表示现在拿到锁的现在，正在执行。后面就是等待队列。
需要协作类去自己实现的获取/释放的方法
获取方法，获取操作会依赖state变量，经常会阻塞，获取不到锁就阻塞。
- 在Semaphore中获取方法就是acquire()方法，获取一个许可证。获取到了state就减一。如果state是0，那么就获取不到，进入等待队列阻塞。
- 在CountDownLatch里面，获取就是await()方法，作用是“等待，直到倒数结束”，如果state不为0就一直阻塞。直到其他线程把state减为0，就可以继续执行。
- 在ReentrantLock中，获取就是lock()方法。state+1。
释放方法，不会阻塞
- 在Semaphore中释放方法就是release()方法，释放一个许可证。state加一。
- 在CountDownLatch里面，释放就是countDown()方法，state减一。
- 在ReentrantLock中，获取就是unlock()方法。state-1。
三、从源码看AQS的用法
1、看看CountDownLatch是怎么使用AQS的
源码分4部分看
初始化构造方法
// 构造方法,count就是要倒数的数量
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
// 调用了Sync的构造方法
this.sync = new Sync(count);
}
// Sync的构造方法,把count赋值给了state变量
Sync(int count) {
setState(count);
}
getCount方法
// 获取当前的count
public long getCount() {
return sync.getCount();
}
等待相关方法
// await等待方法
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
// 如果小于0，说明还没倒数结束，放入等待队列，等待倒数完毕
if (tryAcquireShared(arg) < 0)
// 把当前线程放入等待队列并该阻塞
doAcquireSharedInterruptibly(arg);
}
// 判断state是否为0，为0说明倒数结束了，返回1，不需要去等待了
// state>0说明还没倒数结束，返回-1
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
// 把当前线程放入等待队列并阻塞的方法
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
// 把当前线程包装成Node节点，就是上图阻塞队列中的Node
final Node node = addWaiter(Node.SHARED);
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())// 阻塞线程
throw new InterruptedException();
}
} catch (Throwable t) {
cancelAcquire(node);
throw t;
}
}
// 阻塞线程的方法
private final boolean parkAndCheckInterrupt() {
// 挂起线程的方法，LockSupport.park是对Unsafe的park的包装。
LockSupport.park(this);
return Thread.interrupted();
}
// 挂起线程的方法
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
// Unsafe，把当前线程挂起，进入阻塞状态
U.park(false, 0L);
setBlocker(t, null);
}
释放相关方法
// countDown方法，把计数减1
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
// tryReleaseShared执行state减1操作
if (tryReleaseShared(arg)) {
// tryReleaseShared返回true就会执行这个方法
// 这个方法就会把等待队列中的线程全部唤醒
doReleaseShared();
return true;
}
return false;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
// for循环+CAS自旋，把state减1
for (;;) {
int c = getState();
if (c == 0)
// 如果发现state已经是0了，说明被其它线程操作过了，没必要在减了
return false;
int nextc = c - 1;
if (compareAndSetState(c, nextc))
// 如果已经减为0了，说明倒数结束，返回true，需要去唤醒等待线程起来执行了
return nextc == 0;
}
}
// 唤醒所有等待的线程的方法
private void doReleaseShared() {
/*
* Ensure that a release propagates, even if there are other
* in-progress acquires/releases. This proceeds in the usual
* way of trying to unparkSuccessor of head if it needs
* signal. But if it does not, status is set to PROPAGATE to
* ensure that upon release, propagation continues.
* Additionally, we must loop in case a new node is added
* while we are doing this. Also, unlike other uses of
* unparkSuccessor, we need to know if CAS to reset status
* fails, if so rechecking.
*/
// for循环遍历
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))
continue; // loop to recheck cases
// 在这个方法中调用LockSupport.unpark来唤醒线程。
unparkSuccessor(h);
}
else if (ws == 0 &&
!h.compareAndSetWaitStatus(0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
调用CountDownLatch的await方法时，会尝试获取"共享锁"，不过一开始(还没倒数结束)是获取不到锁的，于是线程被阻塞。而"共享锁"的获取条件是"锁计数器"的值为0，state为0。"锁计数器"的初始值为count，初始化CountDownLatch时设置的值。每当一个线程调用该CountDownLatch对象的countDown()方法时，就降"锁计数器"减1。count个线程调用countDown()方法之后，"锁计数器"才为0，等待获取共享锁的线程才能被全部唤醒继续运行。
2、看看Semaphore是怎么使用AQS的
state代表信号量还剩余的数量。
acquire获取信号量方法
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}
// 熟悉的味道，跟CountDownLatch一样，只不过对state的操作不一样
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
// 在Semaphore中tryAcquireShared根据公平与非公平有2种实现
if (tryAcquireShared(arg) < 0)
// tryAcquireShared返回值小于0，就让当前线程去排队等待
// tryAcquireShared返回值大于0，就代表本次获取成功
doAcquireSharedInterruptibly(arg);
}
非公平的实现
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
final int nonfairTryAcquireShared(int acquires) {
// 不关心队列中是否有线程在等待，直接尝试获取信号量
// for循环+CAS自旋
for (;;) {
// 当前剩余的信号量
int available = getState();
// 判断是否当前剩余信号量数量是否大于等于要申请的信号量数量，本次获取够不够
// acquires可以是大于1的整数，使用的时候可以自定义这个入参
int remaining = available - acquires;
// 如果remaining 小于0了直接返回。代表获取失败，信号量不够了，就会挂起当前线程
if (remaining < 0 ||
// 设置state为当前剩余的值
compareAndSetState(available, remaining))
return remaining;
}
}
公平的实现
protected int tryAcquireShared(int acquires) {
for (;;) {
// 会先判断队列中是否有线程在等待
if (hasQueuedPredecessors())
return -1;
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
release释放信号量方法
public void release() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
// 释放信号量
if (tryReleaseShared(arg)) {
// 跟上面CountDownLatch的doReleaseShared方法作用一样
// 唤醒等待队列的线程
doReleaseShared();
return true;
}
return false;
}
protected final boolean tryReleaseShared(int releases) {
// for循环+CAS设置state的值
for (;;) {
int current = getState();
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
3、看看ReentrantLock是怎么使用AQS的
state代表重入的次数。
lock方法
public void lock() {
sync.acquire(1);
}
public final void acquire(int arg) {
// tryAcquire有公平与非公平的实现
if (!tryAcquire(arg) &&// 如果tryAcquire返回false，说明获取锁没有成功
// addWaiter把当前线程包装成Node，添加到队列中
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
非公平的实现
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// c==0，还没有线程持有这把锁
// CAS去尝试set state为1，尝试获取这把锁
if (compareAndSetState(0, acquires)) {
// CAS成功的话设置这把锁的持有线程为当前线程
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
// 如果当前线程就是持有这把锁的线程，说明是重入了，把state加1
int nextc = c + acquires;
// 如果nextc < 0代表发生了溢出
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
公平的实现
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 只比非公平的实现多了一个判断hasQueuedPredecessors
// 判断队列中是否有线程在等待，如果有别的线程在等待，则返回true
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;
}
unlock方法
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
// 返回true代表锁被释放了
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
// 唤醒线程，里面也是调用LockSupport.unpark唤醒线程
unparkSuccessor(h);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
// 因为是可重入锁，state可能大于1，代表重入的次数，需要计算一下
// releases默认是1
int c = getState() - releases;
// 判断当前线程是不是持有锁的线程
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 如果是重入的情况，c还不为0，就跳过这个判断
if (c == 0) {
// 需要释放锁
free = true;
// 设置当前持有这把锁的线程为null
// 代表目前没有任何线程持有这把锁
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
每次释放锁，先判断是否是当前持有锁的线程释放的，如果不是，则抛异常。如果是的话，重入次数state就减1，如果减到了0，就说明完全释放了。设置state为0。后续就执行唤醒等待线程的方法。
- 我的公众号：Coding抠腚
- 偶尔发发自己最近学到的干货。学习路线，经验，技术分享。技术问题交流探讨。
![Coding抠腚]()
