1.概念

队列同步器AbstractQueuedSynchronizer（后面简称AQS）是实现锁和有关同步器的一个基础框架，其内部通过一个被标识为volatile的名为state的变量来控制多个线程之间的同步状态。多个线程之间可以通过AQS来独占式或共享式的抢占资源。

例如，在锁这个问题上，Java中提供的是synchronized关键字，用这个关键字可以很方便的实现多个线程之间的同步。但这个关键字也有很多缺陷，比如：

• 他不支持超时的获取锁，一个线程一旦没有从synchronized上获取锁，就会卡在这里，没有机会逃脱。所以通常由synchronized造成的死锁是无解的。
• 不可响应中断。
• 不能尝试获取锁。如果尝试获取时没获取到，立刻返回，synchronized不具备这一特性。

而ReentrantLock基于AQS将上述几点都做到了。

2.核心结构

从AbstractQueuedSynchronizer的名字可以看出，AQS中一定是基于队列实现的（Queue）。在AQS内部，是通过链表实现的队列。链表的每个元素是其内部类Node的一个实现。然后AQS通过实例变量head指向队列的头，通过实例变量tail指向队列的尾。
源码：

/*** Head of the wait queue, lazily initialized.  Except for* initialization, it is modified only via method setHead.  Note:* If head exists, its waitStatus is guaranteed not to be* CANCELLED.*/
private transient volatile Node head;/*** Tail of the wait queue, lazily initialized.  Modified only via* method enq to add new wait node.*/
private transient volatile Node tail;/*** The synchronization state.*/
private volatile int state;static final class Node {/** 标识为共享式 */static final Node SHARED = new Node();/** 标识为独占式 */static final Node EXCLUSIVE = null;/** 同步队列中等待的线程等待超时或被中断，需要从等待队列中取消等待，进入该状态的节点状态将不再变化 */static final int CANCELLED =  1;/** 当前节点的后继节点处于等待状态，且当前节点释放了同步状态，需要通过unpark唤醒后继节点，让其继续运行 */static final int SIGNAL    = -1;/** 当前节点等待在某一Condition上，当其他线程调用这个Conditino的signal方法后，该节点将从等待队列恢复到同步队列中，使其有机会获取同步状态 */static final int CONDITION = -2;/** 表示下一次共享式同步状态获取状态将无条件的传播下去 */static final int PROPAGATE = -3;/* 当前节点的等待状态，取值为上述几个常量之一，另外，值为0表示初始状态 */volatile int waitStatus;/* 前驱节点 */volatile Node prev;/* 后继节点 */volatile Node next;/* 等待获取同步状态的线程 */volatile Thread thread;/* 等待队列中的后继节点 */Node nextWaiter;// ...
}

3.实现原理

AQS提供了几个模板方法供实现类自己实现定制功能。
这几个方法是：

• boolean tryAcquire(int arg)：独占式的获取同步状态，通常通过以CAS的方式修改state的值来实现特定功能。
• boolean tryRelease(int arg)：独占式的释放同步状态，通常也是修改state的值。
• int tryAcquireShared(int arg)：共享式的获取同步状态，返回值>=0表示成功，否则失败。
• boolean tryReleaseShared(int arg)：共享式的释放同步状态，同样通过修改state值来实现。
• boolean isHeldExclusively()：表示AQS是否被当前线程独占。

这几个方法的默认实现都会抛出UnsupportedOperationException异常。

目前我们不用关心这几个方法，只要明白其内部是通过控制state的值来管理同步状态即可。

3.1 同步状态的获取

通常，实现类会优先尝试修改state的值，来获取同步状态。例如，如果某个线程成功的将state的值从0修改为1，表示成功的获取了同步状态。 这个修改的过程是通过CAS完成的，所以可以保证线程安全。

反之，如果修改state失败，则会将当前线程加入到AQS的队列中，并阻塞线程。

AQS内部提供了三个方法来修改state的状态，其源码如下：

/*** Returns the current value of synchronization state.* This operation has memory semantics of a {@code volatile} read.* @return current state value*/
protected final int getState() {return state;
}/*** Sets the value of synchronization state.* This operation has memory semantics of a {@code volatile} write.* @param newState the new state value*/
protected final void setState(int newState) {state = newState;
}/*** Atomically sets synchronization state to the given updated* value if the current state value equals the expected value.* This operation has memory semantics of a {@code volatile} read* and write.** @param expect the expected value* @param update the new value* @return {@code true} if successful. False return indicates that the actual*         value was not equal to the expected value.*/
protected final boolean compareAndSetState(int expect, int update) {// See below for intrinsics setup to support thisreturn unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

3.2 同步队列

AQS内部实际上是一个FIFO的双端队列，当线程获取同步状态失败时，就会构建一个Node并添加到队列尾部（此过程是线程安全的，CAS实现），并阻塞当前线程（通过LockSupport.park()方法）； 当释放同步状态时，AQS会先判断head节点是否为null，如果不是null，说明有等待同步状态的线程，就会尝试唤醒head节点，使其重新竞争同步状态。

3.3 独占式同步状态的获取

独占式的意思就是说同一时间只能有一个线程获得同步状态。

AQS会先尝试调用实现类的tryAcquire方法获取同步状态，如果获取失败，会尝试将其封装为Node节点添加到同步队列尾部。

独占式同步状态的获取通过AQS的acquire方法实现。其源码如下：

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

这个方法会先尝试获取一次同步状态（tryAcquire），如果获取失败，会通过addWaiter方法将当前线程加入到同步队列。 并在acquireQueued方法中将当前线程阻塞（LockSupport.park()），并进入自旋状态，以获取同步状态。

下面具体看一下他是如何构建Node并将其添加到队尾的。 首先是addWaiter：

/*** Creates and enqueues node for current thread and given mode.** @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared* @return the new node*/
private Node addWaiter(Node mode) {// mode = Node.EXCLUSIVE，表示是独占模式Node node = new Node(Thread.currentThread(), mode);// 先快速的通过CAS的方式将Node添加到队尾，如果失败，再进入enq方法通过无限循环添加Node pred = tail;if (pred != null) {node.prev = pred;if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}enq(node);return node;
}/*** Inserts node into queue, initializing if necessary. See picture above.* @param node the node to insert* @return node's predecessor*/
private Node enq(final Node node) {// 无限循环的将node添加到队尾，保证能添加成功/*注意：如果是首次向队列中添加Node，那么调addWaiter方法时，tail还是null，所以addWaiter方法不会设置成功，会直接进入这个方法进入这个方法后，由于tail仍然是null，所以会走到第一个if里面，这是会创建一个空的Node出来作为头结点然后再次循环，此时tail不是null了，会进入else的代码中，这时，才会将需要add的Node添加到队列尾部。也就是说，首次创建队列时，会默认加一个空的头结点。*/for (;;) {Node t = tail;if (t == null) { // Must initializeif (compareAndSetHead(new Node()))tail = head;} else {node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}
}

再看下acquireQueued方法：

final boolean acquireQueued(final Node node, int arg) {boolean failed = true;try {boolean interrupted = false;// 进入自旋，不断的获取同步状态for (;;) {// 获取node在队列中的前驱节点final Node p = node.predecessor();if (p == head && tryAcquire(arg)) {// 如果成功进入到这块代码，说明成功的获取了同步状态setHead(node);p.next = null; // help GCfailed = false;return interrupted;}// 获取不成功，调用LockSupport.park()方法将当前线程阻塞if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}
}

shouldParkAfterFailedAcquire方法用户判断是否需要阻塞当前线程，方法内会操作当前队尾节点的前驱节点的waitStatus，并依据waitStatus判断是否需要park。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {int ws = pred.waitStatus;if (ws == Node.SIGNAL) // Node.SIGNAL == -1/** 表明当前节点需要其他线程的唤醒才能继续执行，此时可以安全的park。*/return true;if (ws > 0) {/** Predecessor was cancelled. Skip over predecessors and* indicate retry.*/do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node;} else {/** 如果一个节点是初始状态，即waitStatus=0时，* 将前驱节点的waitStatus设置为-1，表明其需要别的线程唤醒才能继续执行*/compareAndSetWaitStatus(pred, ws, Node.SIGNAL);}return false;
}

当shouldParkAfterFailedAcquire方法判断当前节点需要被park时，会调用parkAndCheckInterrupt将其阻塞：

private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();
}