第十一章 Java多线程——AQS

11.1 AQS简介

AQS是 AbstractQueuedSynchronizer 的简称，即 抽象队列同步器，从字面意思上理解：

• 抽象：抽象类，只实现一些主要逻辑，有些方法由子类实现。
• 队列：使用先进先出（FIFO）队列存储数据。
• 同步：实现了同步的功能。

那AQS有什么用呢？AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的同步器，比如我们提到的ReentrantLock，Semaphore，ReenteantReadWriteLock，SynchronousQueue, FutrueTask等等皆是基于AQS的。

当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器，只要之类实现它的几个protected方法就可以了。

11.2 AQS的数据结构

AQS内部使用了一个volatile的变量state来作为资源的标识。同时定义了几个获取和改版state的protected方法，子类
可以覆盖这些方法来实现自己的逻辑：

getState()
setState()
compareAndSetState()

这三种叫做均是原⼦操作，其中compareAndSetState的实现依赖于Unsafe的compareAndSwapInt()⽅法。

⽽AQS类本身实现的是⼀些排队和阻塞的机制，⽐如具体线程等待队列的维护（如获取资源失败⼊队/唤醒出队等）。它内部使⽤了⼀个先进先出（FIFO）的双端队列，并使⽤了两个指针head和tail⽤于标识队列的头部和尾部。其数据结构如图：

但它并不是直接存储线程，而是存储拥有线程的Node节点。

11.3 资源共享模式

资源有两种共享模式，或者说两种同步方式：

• 独占模式（Exclusive）：资源是独占的，一次只能一个线程获取，如ReetrantLock。
• 共享模式（Share）：同时可以被多个线程获取，具体的资源个数可以通过参数指定。如Semaphore/CountDownLatch。

一般情况下，子类只需要根据需求实现其中一种模式，当然也有同时实现两种模式的同步类，如ReadWriteLock。

AQS中关于这两种资源共享模式的定义源码（均在内部类Node中）。我们来看看Node的结构：

static final class Node {
    /** 标记⼀个结点（对应的线程）在共享模式下等待 */
    static final Node SHARED = new Node();
    /** 标记⼀个结点（对应的线程）在独占模式下等待 */
    static final Node EXCLUSIVE = null;


    /** waitStatus的值，表示该结点（对应的线程）已被取消 */
    static final int CANCELLED =  1;
    /** waitStatus的值，表示后继结点（对应的线程）需要被唤醒 */
    static final int SIGNAL    = -1;
    /** waitStatus的值，表示该结点（对应的线程）在等待某⼀条件 */
    static final int CONDITION = -2;
    /**
     * waitStatus的值，新head节点需要继续唤醒后继结点
     */
    static final int PROPAGATE = -3;

   
    // 等待状态，取值范围，-3，-2，-1，0，1
    volatile int waitStatus;
  
    // 前驱结点
    volatile Node prev;

    // 后继结点
    volatile Node next;

    // 结点对应的线程
    volatile Thread thread;

    // 等待队列⾥下⼀个等待条件的结点
    Node nextWaiter;


    /**
     * 判断共享模式的⽅法
     */
    final boolean isShared() {
        return nextWaiter == SHARED;
    }


    /**
     * Returns previous node, or throws NullPointerException if null.
     * Use when predecessor cannot be null.  The null check could
     * be elided, but is present to help the VM.
     *
     * @return the predecessor of this node
     */
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }


    Node() {    // Used to establish initial head or SHARED marker
    }


    Node(Thread thread, Node mode) {     // Used by addWaiter
        this.nextWaiter = mode;
        this.thread = thread;
    }


    Node(Thread thread, int waitStatus) { // Used by Condition
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
}

// AQS⾥⾯的addWaiter私有⽅法
private Node addWaiter(Node mode) {

    // 使⽤了Node的这个构造函数
    Node node = new Node(Thread.currentThread(), mode);

    // 尝试询问的捷径; 失败时备份到充分询问
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

注意：通过Node我们可以实现两个队列，⼀是通过prev和next实现CLH队列(线程同步队列,双向队列)，⼆是nextWaiter实现Condition条件上的等待线程队列(单向队列)，这个Condition主要⽤在ReentrantLock类中。

11.4 AQS的主要方法源码解析

AQS的设计是基于模板⽅法模式的，它有⼀些⽅法必须要⼦类去实现的，它们主要有：

• isHeldExclusively()：该线程是否正在独占资源。只有⽤到condition才需要去实现它。

• tryAcquire(int)：独占⽅式。尝试获取资源，成功则返回true，失败则返回false。

• tryRelease(int)：独占⽅式。尝试释放资源，成功则返回true，失败则返回false。

• tryAcquireShared(int)：共享⽅式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可⽤资源；正数表示成功，且有剩余资源。

• tryReleaseShared(int)：共享⽅式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

这些⽅法虽然都是 protected ⽅法，但是它们并没有在AQS具体实现，⽽是直接抛出异常（虽然不知道这⾥为什么不使⽤抽象⽅法的实现⽅式）：

protected boolean tryAcquire(int arg) {
     throw new UnsupportedOperationException();
}

⽽AQS实现了⼀系列主要的逻辑。下⾯我们从源码来分析⼀下获取和释放资源的主要逻辑：

11.4.1 获取资源

获取资源的⼊⼝是acquire(int arg)⽅法。arg是要获取的资源的个数，在独占模式下始终为1。我们先来看看这个⽅法的逻辑：

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
          acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
          selfInterrupt();
}

⾸先调⽤tryAcquire(arg)尝试去获取资源。前⾯提到了这个⽅法是在⼦类具体实现的。

如果获取资源失败，就通过addWaiter(Node.EXCLUSIVE)⽅法把这个线程插⼊到等待队列中。其中传⼊的参数代表要插⼊的Node是独占式的。这个⽅法的具体实现：

private Node addWaiter(Node mode) {
    // ⽣成该线程对应的Node节点
    Node node = new Node(Thread.currentThread(), mode);
    // 将Node插⼊队列中
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        // 使⽤CAS尝试，如果成功就返回
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 如果等待队列为空或者上述CAS失败，再⾃旋CAS插⼊
    enq(node);
    return node;
}

// ⾃旋CAS插⼊等待队列
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

上⾯的两个函数⽐较好理解，就是在队列的尾部插⼊新的Node节点，但是需要注意的是由于AQS中会存在多个线程同时争夺资源的情况，因此肯定会出现多个线程同时插⼊节点的操作，在这⾥是通过CAS⾃旋的⽅式保证了操作的线程安全性。

OK，现在回到最开始的aquire(int arg)⽅法。现在通过addWaiter⽅法，已经把⼀个Node放到等待队列尾部了。⽽处于等待队列的结点是从头结点⼀个⼀个去获取资源的。具体的实现我们来看看acquireQueued⽅法：

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        //自旋
        for (;;) {
            final Node p = node.predecessor();
            // 如果node的前驱结点p是head，表示node是第⼆个结点，就可以尝试去获取资源了
            if (p == head && tryAcquire(arg)) {
                // 拿到资源后，将head指向该结点。
                // 所以head所指的结点，就是当前获取到资源的那个结点或null。
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 如果⾃⼰可以休息了，就进⼊waiting状态，直到被unpark()
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

这⾥parkAndCheckInterrupt⽅法内部使⽤到了LockSupport.park(this)，顺便简单介绍⼀下park。

LockSupport类是Java 6
引⼊的⼀个类，提供了基本的线程同步原语。LockSupport实际上是调⽤了Unsafe类⾥的函数，归结到Unsafe⾥，只有两个函数：

• park(boolean isAbsolute, long time)：阻塞当前线程
• unpark(Thread jthread)：使给定的线程停⽌阻塞

所以结点进⼊等待队列后，是调⽤park使它进⼊阻塞状态的。只有头结点的线程是处于活跃状态的。

当然，获取资源的⽅法除了acquire外，还有以下三个：

• acquireInterruptibly：申请可中断的资源（独占模式）
• acquireShared：申请共享模式的资源
• acquireSharedInterruptibly：申请可中断的资源（共享模式）

可中断的意思是，在线程中断时可能会抛出 InterruptedException

总结起来的⼀个流程图：

11.4.2 释放资源

释放资源相比与获取资源来说，会简单许多。在AQS中只有一小段实现。源码：

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

private void unparkSuccessor(Node node) {
    /*
     * 如果状态是负数，尝试把它设置为0
     */
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);


    /*
     * 得到头结点的后继结点head.next
     */
    Node s = node.next;
    // 如果这个后继结点为空或者状态⼤于0
    // 通过前⾯的定义我们知道，⼤于0只有⼀种可能，就是这个结点已被取消
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 等待队列中所有还有⽤的结点，都向前移动
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 如果后继结点不为空，
    if (s != null)
        LockSupport.unpark(s.thread);
}