AQS总结

前言

AQS（Abstract Queued Synchronizer）是JUC并发包中的核心基础组件，作者是大名鼎鼎的Doug Lea。通过AQS可以实现大部分的同步需求。

宏观架构

AQS包括一个state和一个FIFO的CLH队列，如下图所示：


CLH队列中的每个节点Node就可以对应与争用该资源的线程，Node的数据结构如下所示：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

static final class { static final Node SHARED = new Node(); /** 独占模式 */ static final Node EXCLUSIVE = null; /** 当前节点已取消 */ static final int CANCELLED = 1; /** 当前线程处于同步状态，如果取消或释放，通知下一个等待节点 */ static final int SIGNAL = -1; /** wait 在某个condition中 */ static final int CONDITION = -2; static final int PROPAGATE = -3; volatile int waitStatus; volatile Node prev; volatile Node next; /** 当前节点已取消 */ volatile Thread thread; Node nextWaiter; final boolean isShared() { return nextWaiter == SHARED; } final Node predecessor() throws NullPointerException { Node p = prev; if (p == null) throw new NullPointerException(); else return p; } Node() { } 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; } } ``` ### 获取锁的过程 以使用默认构造函数的reentrantLock为例子： ```java ReentrantLock reentrantLock = new ReentrantLock()； reentrantLock.lock();

lock()代码如下：

1 2 3 4 5 6 7

final void lock() { if (compareAndSetState(0, 1)) //成功获得独占的state资源 setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); }

如果当前的state值为0，当前线程获得lock，将state的值通过cas的方式设置为1。如果不是0，则添加到队列中。通过acquire方法去申请资源。

1 2 3 4 5 6

public final void acquire(int arg) { //tryAcquire再次尝试获取锁 if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }

tryAcquire:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { 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; }

再次获取锁尝试失败后，调用addWaiter将线程封装成节点信息，加入到等待队列中。

1 2 3 4 5 6 7 8 9 10 11 12 13 14

private Node addWaiter(Node mode) { Node node = new Node(Thread.currentThread(), mode); // Node pred = tail; if (pred != null) { node.prev = pred; if (compareAndSetTail(pred, node)) { 大专栏  AQS总结 pred.next = node; return node; } } enq(node); return node; }

addWaiter首先会通过cas的方式快速的去添加到队列的尾部，如果添加不成功，调enq(node)再次入队；enq(node)是一个死循环，不断的通过cas去添加到节点，直到成功。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

private Node enq(final Node node) { for (;;) { Node t = tail; if (t == null) { //cas的方式 if (compareAndSetHead(new Node())) tail = head; } else { node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } } }

线程节点进入队列后，调用acquireQueued，acquireQueuedxiang

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

final boolean acquireQueued(final Node node, int arg) { boolean failed = true; try { boolean interrupted = false; for (;;) { final Node p = node.predecessor(); //如果发现自己的前面节点是头节点，表明该节点是正拿到锁的线程，此时再次尝试获取锁资源，因为之前的线程有可能已经解锁了。 if (p == head && tryAcquire(arg)) { setHead(node); p.next = null; // help GC failed = false; return interrupted; } //挂起当前线程 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); } }

最关键的应该是shouldParkAfterFailedAcquire方法，如果每个线程都在这么自旋的去拿锁，cpu肯定炸了。所以，当当前的前一个节点处于SIGNAL状态的时候，可以挂起当前线程。这个操作就好比在排队的时候和前一个人说：我出去买点吃的，你轮到的时候叫我一下。当前面的节点轮到的时候，会唤醒当前线程，然后又开始自旋，判断自己能否拿到同步状态，如果拿到，就获取到了锁，这就是一个完整的获得同步状态的过程。
至于如何挂起当前线程，使用的是LockSupport的park()挂起当前线程。park可以精确的进行挂起，精确到thread。

释放锁的过程

1	reentrantLock.lock(); //释放锁

释放的过程正好相反，通过release来释放锁。

1 2 3 4 5 6 7 8 9 10 11

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的内容主要是：获取state的值，减去要释放的值，如果state已经是0，把当前的线程设置为null。要注意的是，这里完全没有使用cas，因为当前线程还持有锁，绝对的线程安全。

1 2 3 4 5 6 7 8 9 10 11 12

protected final boolean tryRelease(int releases) { int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; if (c == 0) { free = true; setExclusiveOwnerThread(null); } setState(c); return free; }

最为关键的 unparkSuccessor(h)，这个时候头节点已经处于了获取同步的状态，通过unparkSuccessor(h)来唤醒头节点的后一个节点。从而后一个节点就可以自旋的去获取同步状态。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

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); }

总结

个人认为AQS在很多地方使用cas和自旋的方式，一定程度上提升吞吐率，之前看到过测试ReentrantLock的吞吐比synchronized要高很多，不对synchronized一直在优化，估计现在性能也差不多了，以后做个测试。本文只是总结了AQS的独占式的获取同步状态，还有共享式的获取同步状态，还支持很多的特性，将在后面进行总结。