AQS介绍
在AQS维护的CLH队列锁中，每个节点（Node）代表着一个需要获取锁的线程。该Node中有两个常量SHARE、EXCLUSIVE。其中SHARE代表着共享模式，EXCLUSIVE代表着独占模式。
其中共享模式是允许多个线程可以获取同一个锁，而独占模式则一个锁只能被一个线程持有，其他线程必须要等待。
AQS结构：
// 头结点，虚拟节点，并不在阻塞队列中
private transient volatile Node head;
// 阻塞的尾节点，每个新的节点进来，都插入到最后，也就形成了一个隐视的链表
private transient volatile Node tail;
// 这个状态表示的count数量，只是为了AQS统一，这里叫做state
private volatile int state;
// 代表当前持有独占锁的线程
private transient ThreadexclusiveOwnerThread; //继承自AbstractOwnableSynchronizer
预热题：CountDownLatch 和?CyclicBarrier 有什么区别？
CountDownLatch的构造函数(采用的是一种公平锁机制)
同步队列的基本结构
CountDownLatch源码分析
构造方法，需要传入一个不小于 0 的整数：
public CountDownLatch(int count) {
? ? if (count < 0) throw new IllegalArgumentException("count < 0");
? ? this.sync = new Sync(count);
}// 内部封装一个 Sync 类继承自 AQS private static final class Sync extends AbstractQueuedSynchronizer {
? ? Sync(int count) {
? ? ? ? // 这样就 state == count 了? ? ? ? setState(count);
? ? }
? ? ...
}
思路分析：AQS 里面的 state 是一个整数值，这边用一个 int count 参数其实初始化就是设置了这个值，所有调用了 await 方法的等待线程会挂起，然后有其他一些线程会做 state = state - 1 操作，当 state 减到 0 的同时，那个线程会负责唤醒调用了 await 方法的所有线程。
对于 CountDownLatch，我们仅仅需要关心两个方法，一个是 countDown() 方法，另一个是 await() 方法。countDown() 方法每次调用都会将 state 减 1，直到 state 的值为 0；而 await 是一个阻塞方法，当 state 减为 0 的时候，await 方法才会返回。await 可以被多个线程调用，小结：所有调用了 await 方法的线程阻塞在 AQS 的阻塞队列中，等待条件满足（state == 0），将线程从队列中一个个唤醒过来。
我们用以下程序来分析源码，t1 和 t2 负责调用 countDown() 方法，t3 和 t4 调用 await 方法阻塞：
public class CountDownLatchDemo {
? ? public static void main(String[] args) {
? ? ? ? CountDownLatch latch = new CountDownLatch(2);
? ? ? ? Thread t1 = new Thread(new Runnable() {
? ? ? ? ? ? @Override? ? ? ? ? ?
? ? ? ? ? ?public void run() {
? ? ? ? ? ? ? ? try {
? ? ? ? ? ? ? ? ? ? Thread.sleep(5000);
? ? ? ? ? ? ? ? } catch (InterruptedException ignore) {
? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? // 休息 5 秒后(模拟线程工作了 5 秒)，调用 countDown()? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ?latch.countDown();
? ? ? ? ? ? }
? ? ? ? }, "t1");
? ? ? ? Thread t2 = new Thread(new Runnable() {
? ? ? ? ? ? @Override? ? ? ? ? ?
? ? ? ? ? ? public void run() {
? ? ? ? ? ? ? ? try {
? ? ? ? ? ? ? ? ? ? Thread.sleep(10000);
? ? ? ? ? ? ? ? } catch (InterruptedException ignore) {
? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? // 休息 10 秒后(模拟线程工作了 10 秒)，调用 countDown()? ? ? ? ? ? ? ? latch.countDown();
? ? ? ? ? ? }
? ? ? ? }, "t2");
? ? ? ? t1.start();
? ? ? ? t2.start();
? ? ? ? Thread t3 = new Thread(new Runnable() {
? ? ? ? ? ? @Override? ? ? ? ? ?
? ? ? ? ? ? public void run() {
? ? ? ? ? ? ? ? try {
? ? ? ? ? ? ? ? ? ? // 阻塞，等待 state 减为 0? ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? ? ?latch.await();
? ? ? ? ? ? ? ? ? ? System.out.println("线程 t3 从 await 中返回了");
? ? ? ? ? ? ? ? } catch (InterruptedException e) {
? ? ? ? ? ? ? ? ? ? System.out.println("线程 t3 await 被中断");
? ? ? ? ? ? ? ? ? ? Thread.currentThread().interrupt();
? ? ? ? ? ? ? ? }
? ? ? ? ? ? }
? ? ? ? }, "t3");
? ? ? ? Thread t4 = new Thread(new Runnable() {
? ? ? ? ? ? @Override? ? ? ? ? ?
? ? ? ? ? ? public void run() {
? ? ? ? ? ? ? ? try {
? ? ? ? ? ? ? ? ? ? // 阻塞，等待 state 减为 0? ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? ? ? ?latch.await();
? ? ? ? ? ? ? ? ? ? System.out.println("线程 t4 从 await 中返回了");
? ? ? ? ? ? ? ? } catch (InterruptedException e) {
? ? ? ? ? ? ? ? ? ? System.out.println("线程 t4 await 被中断");
? ? ? ? ? ? ? ? ? ? Thread.currentThread().interrupt();
? ? ? ? ? ? ? ? }
? ? ? ? ? ? }
? ? ? ? }, "t4");
? ? ? ? t3.start();
? ? ? ? t4.start();
? ? }
}
上述程序，大概在过了 10 秒左右的时候，会输出：
线程 t3 从 await 中返回了
线程 t4 从 await 中返回了// 这两条输出，顺序不是绝对的// 后面的分析，我们假设 t3 先进入阻塞队列
首先，我们来看 await() 方法，它代表线程阻塞，等待 state 的值减为 0。
public void await() throws InterruptedException {
? ? sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)? ? throws InterruptedException {
? ? ? ? if (Thread.interrupted())
? ? ? ? throw new InterruptedException();
? ? ? ? // t3 和 t4 调用 await 的时候，state 都大于 0。? ? // 也就是说，这个 if 返回 true，然后往里看? ?
? ? ? if (tryAcquireShared(arg) < 0)
? ? ? ? doAcquireSharedInterruptibly(arg);
}
// 只有当 state == 0 的时候，这个方法才会返回 1
protected int tryAcquireShared(int acquires) {
? ? return (getState() == 0) ? 1 : -1;
}
从方法名我们就可以看出，这个方法是获取共享锁，并且此方法是可中断的（中断的时候抛出 InterruptedException 退出这个方法）。
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
? ? // 1. 入队：共享锁和独占锁共用逻辑? ??
final Node node = addWaiter(Node.SHARED);
? ? boolean failed = true;
? ? try {
? ? ? ? for (;;) {
? ? ? ? ? ? final Node p = node.predecessor();
? ? ? ? ? ? if (p == head) {
? ? ? ? ? ? ? ? // 同上，只要 state 不等于 0，那么这个方法返回 -1? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ?int r = tryAcquireShared(arg);
? ? ? ? ? ? ? ? if (r >= 0) {
? ? ? ? ? ? ? ? ? ? setHeadAndPropagate(node, r);
? ? ? ? ? ? ? ? ? ? p.next = null; // help GC? ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? failed = false;
? ? ? ? ? ? ? ? ? ? return;
? ? ? ? ? ? ? ? }
? ? ? ? ? ? }
? ? ? ? ? ? // 2? ?这里是主要逻辑，形成阻塞? ? ? ? ??
? ? ? ? ? ?if (shouldParkAfterFailedAcquire(p, node) &&
? ? ? ? ? ? ? ? parkAndCheckInterrupt())
? ? ? ? ? ? ? ? throw new InterruptedException();
? ? ? ? }
? ? } finally {
? ? ? ? if (failed)
? ? ? ? ? ? cancelAcquire(node);
? ? }
}
countDown() 方法:
public void countDown() {
? ? sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
? ? // 只有当 state 减为 0 的时候，tryReleaseShared 才返回 true? ? // 否则只是简单的 state = state - 1 那么 countDown 方法就结束了?
? if (tryReleaseShared(arg)) {
? ? ? ? // 唤醒 await 的线程? ? ? ? doReleaseShared();
? ? ? ? return true;
? ? }
? ? return false;
}// 这个方法很简单，用自旋的方法实现 state 减 1protected boolean tryReleaseShared(int releases) {
? ? for (;;) {
? ? ? ? int c = getState();
? ? ? ? if (c == 0)
? ? ? ? ? ? return false;
? ? ? ? int nextc = c-1;
? ? ? ? if (compareAndSetState(c, nextc))
? ? ? ? ? ? return nextc == 0;
? ? }
}
countDown 方法就是每次调用都将 state 值减 1，如果 state 减到 0 了，那么就调用下面的方法进行唤醒阻塞队列中的线程：
// 调用这个方法的时候，state == 0// 这个方法先不要看所有的代码，按照思路往下到我写注释的地方，其他的之后还会仔细分析private void doReleaseShared() {
? ? for (;;) {
? ? ? ? Node h = head;
? ? ? ? if (h != null && h != tail) {
? ? ? ? ? ? int ws = h.waitStatus;
? ? ? ? ? ? // t3 入队的时候，已经将头节点的 waitStatus 设置为 Node.SIGNAL（-1） 了? ? ? ? ? ?
? ? ? ? ? ?if (ws == Node.SIGNAL) {
? ? ? ? ? ? ? ? if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
? ? ? ? ? ? ? ? ? ? continue;? ? ? ? ? ? // loop to recheck cases? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? // 就是这里，唤醒 head 的后继节点，也就是阻塞队列中的第一个节点? ? ? ? ? ? ? ? ??
? ? ? ? ? ? ? ? ? ?unparkSuccessor(h);
? ? ? ? ? ? }
? ? ? ? ? ? else if (ws == 0 &&
? ? ? ? ? ? ? ? ? ? !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))? ? ? ? ? ?
? ? ? ? ? ? ? ? ? ? ?continue;? ? ? ? ? ? ? ? // loop on failed CAS? ? ?
? }
? ? ? ? if (h == head)? ? ? ? ? ? ? ? ? // loop if head changed? ? ? ? ?
? ? ? ? ?break;
? ? }
}
一旦 t3 被唤醒后，我们继续回到 await 的这段代码，parkAndCheckInterrupt 返回，我们先不考虑中断的情况：
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
? ? final Node node = addWaiter(Node.SHARED);
? ? boolean failed = true;
? ? try {
? ? ? ? for (;;) {
? ? ? ? ? ? final Node p = node.predecessor();
? ? ? ? ? ? if (p == head) {
? ? ? ? ? ? ? ? int r = tryAcquireShared(arg);
? ? ? ? ? ? ? ? if (r >= 0) {
? ? ? ? ? ? ? ? ? ? setHeadAndPropagate(node, r); // 2. 这里是下一步? ? ? ? ? ? ? ? ? ? p.next = null; // help GC? ? ? ? ? ? ? ? ? ? failed = false;
? ? ? ? ? ? ? ? ? ? return;
? ? ? ? ? ? ? ? }
? ? ? ? ? ? }
? ? ? ? ? ? if (shouldParkAfterFailedAcquire(p, node) &&
? ? ? ? ? ? ? ? // 1. 唤醒后这个方法返回? ? ? ? ? ? ? ? parkAndCheckInterrupt())
? ? ? ? ? ? ? ? throw new InterruptedException();
? ? ? ? }
? ? } finally {
? ? ? ? if (failed)
? ? ? ? ? ? cancelAcquire(node);
? ? }
}
接下来，t3 会进到 setHeadAndPropagate(node, r) 这个方法，先把 head 给占了，然后唤醒队列中其他的线程：
private void setHeadAndPropagate(Node node, int propagate) {
? ? Node h = head; // Record old head for check below? ? setHead(node);
? ? // 下面说的是，唤醒当前 node 之后的节点，即 t3 已经醒了，马上唤醒 t4? ? // 类似的，如果 t4 后面还有 t5，那么 t4 醒了以后，马上将 t5 给唤醒了? ? if (propagate > 0 || h == null || h.waitStatus < 0 ||
? ? ? ? (h = head) == null || h.waitStatus < 0) {
? ? ? ? Node s = node.next;
? ? ? ? if (s == null || s.isShared())
? ? ? ? ? ? // 又是这个方法，只是现在的 head 已经不是原来的空节点了，是 t3 的节点了? ? ? ? ? ?
? ? ? ? doReleaseShared();
? ? }
}
又回到这个方法了，那么接下来，我们好好分析 doReleaseShared 这个方法，我们根据流程，头节点 head 此时是 t3 节点了：
// 调用这个方法的时候，
state == 0private void doReleaseShared() {
? ? for (;;) {
? ? ? ? Node h = head;
? ? ? ? // 1. h == null: 说明阻塞队列为空? ? ? ? // 2. h == tail: 说明头结点可能是刚刚初始化的头节点，? ? ? ? //? 或者是普通线程节点，但是此节点既然是头节点了，那么代表已经被唤醒了，阻塞队列没有其他节点了? ? ? ? // 所以这两种情况不需要进行唤醒后继节点? ? ? ?
if (h != null && h != tail) {
? ? ? ? ? ? int ws = h.waitStatus;
? ? ? ? ? ? // t4 将头节点(此时是 t3)的 waitStatus 设置为 Node.SIGNAL（-1） 了? ? ? ? ? ? if (ws == Node.SIGNAL) {
? ? ? ? ? ? ? ? // 这里 CAS 失败的场景请看下面的解读? ? ? ? ? ? ? ? if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
? ? ? ? ? ? ? ? ? ? continue;? ? ? ? ? ? // loop to recheck cases? ? ? ? ? ? ? ? // 就是这里，唤醒 head 的后继节点，也就是阻塞队列中的第一个节点? ? ? ? ? ??
? ? ? ? ? ? ? ? ? unparkSuccessor(h);
? ? ? ? ? ? }
? ? ? ? ? ? else if (ws == 0 &&
? ? ? ? ? ? ? ? ? ? // 这个 CAS 失败的场景是：执行到这里的时候，刚好有一个节点入队，入队会将这个 ws 设置为 -1? ? ? ? ? ? ? ? ? ? !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
? ? ? ? ? ? ? ? continue;? ? ? ? ? ? ? ? // loop on failed CAS? ? ?
? }
? ? ? ? // 如果到这里的时候，前面唤醒的线程已经占领了 head，那么再循环? ? ? ? // 否则，就是 head 没变，那么退出循环，? ? ? ? // 退出循环是不是意味着阻塞队列中的其他节点就不唤醒了？当然不是，唤醒的线程之后还是会调用这个方法的? ? ? ?
? ? ?if (h == head)? ? ? ? ? ? ? ? ? // loop if head changed? ? ? ? ? ?
? ? break;
? ? }
}
小结：
我们知道在使用Java内置锁时，可以使用wait、notify方法来阻塞、唤醒线程，但是AQS并没有采用该模式，而是通过LockSupport.park() 和 LockSupport.unpark() 的本地方法来实现线程的阻塞和唤醒。
