深入理解AQS（源码剖析）

1、概述

1.1、基本介绍：
AQS（Abstract Queued Synchronizer）是一个抽象的队列同步器，通过维护一个共享资源状态（volatile int state）和一个先进先出（FIFO）的线程等待队列（CLH）来实现一个多线程访问共享资源的同步框架。

1.2、原理：
AQS为每个共享资源都设置一个共享资源锁，线程在需要访问共享资源时首先需要获取共享资源锁，如果获取到了共享资源锁，便可以在当前线程中使用该共享资源，如果获取不到，则将该线程放入线程等待队列，等待下一次资源调度，具体的流程如下图所示。

它维护了一个volatile int类型的变量，用于表示当前对的同步状态。volatile不能保证操作的原子性，但是能够保证当前变量的可见性。state的访问方式有三种，

• getState()
• setState()
• compareAndSetState()

都是原子操作， 其中 ，compareAndSetState的实现依赖于Unsafe的compareAndSwapInt()

AQS定义了两种资源共享方式：

• 独占式（Exclusive） ：只有一个线程能执行，具体的Java实现有ReentrantLock。
• 共享式（Share）：多个线程可同时执行，具体的Java实现有Semaphore和CountDownLatch。

AQS只是一个框架，具体资源的获取、释放都交由自定义同步器去实现。不同的自定义同步器争用共享资源的方式也不同，自定义同步器在实现时只需实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护，如获取资源失败入队、 唤醒出队等，AQS已经在顶层实现好，不需要具体的同步器再做处理。自定义同步器主要需要实现的方法如下：

• isHeldExclusively()：查询该线程是否正在独占资源。只有用到condition才需要去实现它。
• tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。
• tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。
• tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
• tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

ReentrantLock对AQS的独占方式实现为：ReentrantLock中的state初始值为0时表示无锁状态 。在线程执行tryAcquire() 获取该锁后ReentrantLock中的state+1，这时该线程独占ReentrantLock锁，其他线程在通过tryAcquire()获取锁时均会失败，直到该线程释放锁后state再次为 0，其他线程才有机会获取该锁。该线程在释放锁之前可以重复获取此锁，每获取一次便会执行一次state+1，因此ReentrantLock属于可重入锁。但获取多少次锁就要释放多少次锁，这样才能保证state最终为0。如果获取锁的次数多于释放锁的次数，则会出现该线程一直持有该锁的情况；如果获取锁的次数少于释放锁的次数，则运行中的程序会报锁异常。

CountDownLatch对AQS的共享方式实现为：CountDownLatch将任务分为N个子线程去执行，将state也初始化为N，N与线程的个数一致，N个子线程是并行执行的，每个子线程都在执行完成后countDown()一次，state会执行CAS操作并减1。在所有子线程都执行完成（state=0）时会unpark()主线程，然后主线程会从await()返回，继续执行后续的动作。

一般来说，自定义同步器要么采用独占方式，要么采用共享方式，实现类只需实现tryAcquire、tryRelease或tryAcquireShared、tryReleaseShared中的一组即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，例如ReentrantReadWriteLock在读取时采用了共享方式，在写入时采用了独占方式。

2、源码分析

2.1、Node节点
AQS中定义了一个静态内部类Node，对等待获取资源的线程进行了封装，其包含了需要同步的线程本身及其等待状态，如是否被阻塞、是否等待唤醒、是否已经被取消等。

变量waitStatus则表示当前Node结点的等待状态，共有5种取值

• CANCELLED(1)：表示当前结点已取消调度。当timeout或被中断（响应中断的情况下），会触发变更为此状态，进入该状态后的结点将不会再变化。
• SIGNAL(-1)：表示后继结点在等待当前结点唤醒。后继结点入队时，会将前继结点的状态更新为SIGNAL。
• CONDITION(-2)：表示结点等待在Condition上，当其他线程调用了Condition的signal()方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁。
• PROPAGATE(-3)：共享模式下，前继结点不仅会唤醒其后继结点，同时也可能会唤醒后继的后继结点。
• 0：新结点入队时的默认状态。

2.2、acquire(int)
此方法是独占模式下线程获取共享资源的顶层入口。如果获取到资源，线程直接返回，否则进入等待队列，直到获取到资源为止，且整个过程忽略中断的影响。这也正是lock()的语义，当然不仅仅只限于lock()。获取到资源后，线程就可以去执行其临界区代码了。下面是acquire()的源码：

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

函数流程如下：

1. 调用tryAcquire()方法尝试获取资源，获取成功返回true，否则返回false
2. 调用addWaiter()方法，以独占模式将当前线程封装为Node节点并添加到线程等待队列尾部
3. acquireQueued()使线程阻塞在等待队列中获取资源，一直获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false。
4. 如果线程在等待过程中被中断过，它是不响应的。只是获取资源后才再进行自我中断selfInterrupt()，将中断补上。

2.2.1、tryAcquire(int)
此方法尝试去获取独占资源。如果获取成功，则直接返回true，否则直接返回false。这也正是tryLock()的语义，当然不仅仅只限于tryLock()。如下是tryAcquire()的源码：

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

从源码中可以看出，该方法是直接抛出异常，这启示我们需要子类重写该方法，前面说过，AQS只是一个框架，具体资源的获取/释放方式交由自定义同步器去实现，实现类只需实现tryAcquire、tryRelease或tryAcquireShared、tryReleaseShared中的一组即可。
2.2.2、addWaiter(Node)
将当前线程及相关信息封装成Node节点并添加到队尾，返回该节点。源码如下：

private Node addWaiter(Node mode) {
		// 以给定模式构造结点。mode有两种：EXCLUSIVE（独占）和SHARED（共享）
        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;
    }

2.2.3、enq(Node)
此方法用于将node加入队尾。源码如下：

private Node enq(final Node node) {
		// CAS自旋，直到成功加入队尾
        for (;;) {
            Node t = tail;
            if (t == null) { // 队列为空，创建一个空的标志结点作为head结点，并将tail也指向它
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else { // 正常流程，放入队尾
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

2.2.4、acquireQueued(Node, int)
通过tryAcquire()和addWaiter()，该线程获取资源失败，已经被放入等待队列尾部了，接下来进入等待状态休息，直到其他线程彻底释放资源后唤醒自己，自己再拿到资源，然后就可以去干自己想干的事了。源码如下：

final boolean acquireQueued(final Node node, int arg) {
        // 标记是否成功拿到资源
        boolean failed = true;
        try {
        	// 标记等待过程中是否被中断过
            boolean interrupted = false;
            // 自旋
            for (;;) {
            	// 获得前驱
                final Node p = node.predecessor();
                // 如果前驱是head，即该结点已成老二，那么便有资格去尝试获取资源（可能是老大释放完资源唤醒自己的，当然也可能被interrupt了）
                if (p == head && tryAcquire(arg)) {
                	//拿到资源后，将head指向该结点。所以head所指的标杆结点，就是当前获取到资源的那个结点或null。
                    setHead(node);
                    // setHead中node.prev已置为null，此处再将head.next置为null，就是为了方便GC回收以前的head结点。也就意味着之前拿完资源的结点出队了
                    p.next = null; // help GC
                    // 成功获取资源
                    failed = false;
                    // 返回等待过程中是否被中断过
                    return interrupted;
                }
                // 如果自己可以休息了，就通过park()进入waiting状态，直到被unpark()。如果不可中断的情况下被中断了，那么会从park()中醒过来，发现拿不到资源，从而继续进入park()等待
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;// 如果等待过程中被中断过，哪怕只有那么一次，就将interrupted标记为true
            }
        } finally {
        	// 如果等待过程中没有成功获取资源（如timeout，或者可中断的情况下被中断了），那么取消结点在队列中的等待
            if (failed)
                cancelAcquire(node);
        }
    }

2.2.4.1、shouldParkAfterFailedAcquire(Node, Node)
此方法用于检查并更新未能获取的节点的状态，源码如下：

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
		// 获得前驱的状态
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            // 如果已经告诉前驱拿完号后通知自己一下，那就可以安心休息了
            return true;
        if (ws > 0) {
            // 如果前驱被取消了，那就一直往前找，直到找到最近一个正常等待的状态，并排在它的后边
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            // //如果前驱正常，那就把前驱的状态设置成SIGNAL
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

2.2.4.2、parkAndCheckInterrupt()
如果线程找好安全休息点后，那就可以安心去休息了。此方法就是让线程去休息，真正进入等待状态。

private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);// 调用park()使线程进入waiting状态
        return Thread.interrupted();// 如果被唤醒，查看自己是不是被中断的
    }

park()会让当前线程进入waiting状态。在此状态下，有两种途径可以唤醒该线程：1）被unpark()；2）被interrupt()。需要注意的是Thread.interrupted()会清除当前线程的中断标记位。

2.2.4.3、小结
看了shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()，现在让我们再回到acquireQueued()，总结下该函数的具体流程：

1. 节点进入队尾后，检查状态，找到安全休息点
2. 调用park()进入waiting状态，等待unpark()或interrupt()唤醒自己
3. 被唤醒后，看自己是不是有资格能拿到号。如果拿到，head指向当前结点，并返回从入队到拿到号的整个过程中是否被中断过；如果没拿到，继续流程1

2.2.5、acquire()函数流程

1. 调用自定义同步器的tryAcquire()尝试直接去获取资源，如果成功则直接返回
2. 没成功，则addWaiter()将该线程加入等待队列的尾部，并标记为独占模式
3. acquireQueued()使线程在等待队列中休息，有机会时（轮到自己，会被unpark()）会去尝试获取资源。获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false
4. 如果线程在等待过程中被中断过，它是不响应的。只是获取资源后才再进行自我中断selfInterrupt()，将中断补上

2.3、release(int)
此方法是独占模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果彻底释放了（即state=0）,它会唤醒等待队列里的其他线程来获取资源。这也正是unlock()的语义，当然不仅仅只限于unlock()。下面是release()的源码：

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);// 唤醒等待队列里的下一个线程
            return true;
        }
        return false;
    }

从源码可以看出该方法调用tryRelease()来释放资源，根据tryRelease()的返回值来判断该线程是否已经完成释放掉资源了。

2.3.1、tryRelease(int)
此方法尝试去释放指定量的资源。下面是tryRelease()的源码：

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

跟tryAcquire()一样，这个方法是需要独占模式的自定义同步器去实现的。正常来说，tryRelease()都会成功的，因为这是独占模式，该线程来释放资源，那么它肯定已经拿到独占资源了，直接减掉相应量的资源即可(state-=arg)，也不需要考虑线程安全的问题。

2.3.2、unparkSuccessor(Node)
此方法用于唤醒等待队列中下一个线程。下面是源码：

private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0) // 置零当前线程所在的结点状态，允许失败
            compareAndSetWaitStatus(node, ws, 0);
        Node s = node.next;
        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);// 唤醒
    }

用unpark()唤醒等待队列中最前边的那个未放弃线程。

2.4、acquireShared(int)
此方法是共享模式下线程获取共享资源的顶层入口。它会获取指定量的资源，获取成功则直接返回，获取失败则进入等待队列，直到获取到资源为止，整个过程忽略中断。下面是acquireShared()的源码：

public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
    }

这里tryAcquireShared()依然需要自定义同步器去实现。但是AQS已经把其返回值的语义定义好了：负值代表获取失败；0代表获取成功，但没有剩余资源；正数表示获取成功，还有剩余资源，其他线程还可以去获取。所以这里acquireShared()的流程就是：

1. tryAcquireShared()尝试获取资源，成功（>=0）则直接返回
2. 失败则通过doAcquireShared()进入等待队列，直到获取到资源为止才返回

2.4.1、doAcquireShared(int)
此方法用于将当前线程加入等待队列尾部休息，直到其他线程释放资源唤醒自己，自己成功拿到相应量的资源后才返回。下面是doAcquireShared()的源码：

private void doAcquireShared(int arg) {
        final Node node = addWaiter(Node.SHARED);// 加入队列尾部
        boolean failed = true;// 是否成功标志
        try {
            boolean interrupted = false;// 等待过程中是否被中断过的标志
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {// 如果前驱是head，前面我们知道head是拿到资源的线程，因此很有可能将唤醒自己
                    int r = tryAcquireShared(arg);// 尝试获取资源
                    if (r >= 0) {// 成功
                        setHeadAndPropagate(node, r);// 将head指向自己，还有剩余资源可以再唤醒之后的线程
                        p.next = null; // help GC
                        if (interrupted)// 如果等待过程中被打断过，此时将中断补上
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                // 判断状态，寻找安全点，进入waiting状态，等着被unpark()或interrupt()
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

跟acquireQueued()很相似，只不过这里将补中断的selfInterrupt()放到doAcquireShared()里了，而独占模式是放到acquireQueued()之外。

2.4.1.1、setHeadAndPropagate(Node, int)

private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        setHead(node);// head指向自己
        // 如果还有剩余量，继续唤醒下一个邻居线程
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }

此方法在setHead()的基础上多了一步，就是自己苏醒的同时，如果条件符合（比如还有剩余资源），还会去唤醒后继结点，毕竟是共享模式。

2.5、releaseShared(int)
此方法是共享模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果成功释放且允许唤醒等待线程，它会唤醒等待队列里的其他线程来获取资源。下面是releaseShared()的源码：

public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) { // 尝试释放资源
            doReleaseShared();// 唤醒后继结点
            return true;
        }
        return false;
    }

跟独占模式下的release()相似，但有一点稍微需要注意：独占模式下的tryRelease()在完全释放掉资源（state=0）后，才会返回true去唤醒其他线程，这主要是基于独占下可重入的考量；而共享模式下的releaseShared()则没有这种要求，共享模式实质就是控制一定量的线程并发执行，那么拥有资源的线程在释放掉部分资源时就可以唤醒后继等待结点。

2.5.1、doReleaseShared()
此方法主要用于唤醒后继。下面是它的源码：

private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;// loop to recheck cases
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;  // loop on failed CAS
            }
            if (h == head)  // loop if head changed
                break;
        }
    }

2.6、小结
独占和共享两种模式下获取-释放资源(acquire-release、acquireShared-releaseShared)的源码剖析完毕，值得注意的是，acquire()和acquireShared()两种方法下，线程在等待队列中都是忽略中断的。AQS也支持响应中断的，即acquireInterruptibly()/acquireSharedInterruptibly()，相应的源码跟acquire()和acquireShared()差不多，这里不在赘述。

至此，AQS的源码分析就到这里，相信对AQS原理的理解会更进一步。