JDK源码之AQS源码剖析
除特别注明外，本站所有文章均为原创，转载请注明地址
AbstractQueuedSynchronizer(AQS)是JDK中实现并发编程的核心，平时我们工作中经常用到的ReentrantLock，CountDownLatch等都是基于它来实现的。
AQS类中维护了一个双向链表(FIFO队列)， 如下图所示：
队列中的每个元素都用一个Node表示，我们可以看到，Node类中有几个静态常量表示的状态：
static final class Node { /** Marker to indicate a node is waiting in shared mode */ static final Node SHARED = new Node(); /** Marker to indicate a node is waiting in exclusive mode */ static final Node EXCLUSIVE = null; /** waitStatus value to indicate thread has cancelled */ static final int CANCELLED = 1; /** waitStatus value to indicate successor's thread needs unparking */ static final int SIGNAL = -1; /** waitStatus value to indicate thread is waiting on 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) { this.nextWaiter = mode; this.thread = thread; } Node(Thread thread, int waitStatus) { this.waitStatus = waitStatus; this.thread = thread; } }
此外，AQS中通过一个state的volatile变量表示同步状态。
那么AQS是如何通过队列实现锁操作的呢？
一.获取锁操作
下面的是AQS中执行获取锁的代码:
public final void acquire(int arg) {
/**通过tryAcquire获取锁，如果成功获取到锁直接终止(selfInterrupt),否则将当前线程插入队列
* 这里的Node.EXCLUSIVE表示创建一个独占模式的节点
*/ if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }
然而实际上，AQS中并没有实现上面的tryAcquire(arg)方法，具体获取锁的操作需要由其子类比如ReentrantLock中的Sync实现：
protected final boolean tryAcquire(int acquires) {
//取到当前线程 final Thread current = Thread.currentThread();
//获取到state值(前文提到) int c = getState();
//state为0标识当前没有线程占有锁
//如果队列中前面没有元素(因为是公平锁的原因，非公平锁中不进行判断，如果state为0直接获取到锁)，CAS修改当前值 if (c == 0) { if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
//标识当前线程成功获取锁 setExclusiveOwnerThread(current); return true; } }
//state不为0，且占有锁的线程是当前线程(这里涉及到一个可重入锁的概念) else if (current == getExclusiveOwnerThread()) {
//增加重入次数 int nextc = c + acquires;
//如果次数值溢出，抛出异常 if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; }
//如果锁已经被其它线程占用,获取锁失败 return false; }
上面的代码注释中提到了可重入锁的概念，可重入锁又叫递归锁，简单来讲就是已经获取到锁的线程还可以再次获取到同一个锁，我们通常使用的syschronized操作,ReentrantLock都属于可重入锁。自旋锁则不属于可重入锁。
下面我们再看一下如果tryAcquire失败，AQS是如何处理的：
private Node addWaiter(Node mode) {
//创建一个队列的Node Node node = new Node(Thread.currentThread(), mode); //获取当前队列尾部 Node pred = tail; if (pred != null) {
//CAS操作尝试插入Node到等待队列，这里只尝试一次 node.prev = pred; if (compareAndSetTail(pred, node)) { pred.next = node; return node; } }
//如果添加失败，enq这里会做自旋操作，知道插入成功。 enq(node); return node; }
//自旋操作添加元素到队列尾部
private Node enq(final Node node) { for (;;) {
//获取尾节点 Node t = tail;
//如果尾节点为空，说明当前队列是空，需要初始化队列 if (t == null) {
//初始化当前队列 if (compareAndSetHead(new Node())) tail = head; } else {
//通过CAS操作插入Node，设置Node为队列的尾节点，并返回Node node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } } }
/**
* 如果插入的节点前面是head,尝试获取锁，
*/
final boolean acquireQueued(final Node node, int arg) { boolean failed = true; try { boolean interrupted = false;
//自旋操作 for (;;) {
//获取当前插入节点的前置节点 final Node p = node.predecessor();
//前置节点是head，尝试获取锁 if (p == head && tryAcquire(arg)) {
//设置head为当前节点，表示获取锁成功 setHead(node); p.next = null; // help GC failed = false; return interrupted; }
//是否挂起当前线程，如果是，则挂起线程 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); } }
上面的代码有些复杂，这里解释一下，之前的addWaiter代码已经将node加入了等待队列，所以这里需要让节点队列中挂起，等待唤醒。队列的head节点代表的是当前占有锁的节点，首先判断插入的node的前置节点是否是head，如果是，尝试获取锁(tryAcquire),如果获取成功则将head设置为当前节点；如果获取失败需要判断是否挂起当前线程。
/**
* 判断是否可以挂起当前线程
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//ws为node前置节点的状态 int ws = pred.waitStatus; if (ws == Node.SIGNAL) //如果前置节点状态为SIGNAL，当前节点可以挂起 return true; if (ws > 0) {
//通过循环跳过所有的CANCELLED节点，找到一个正常的节点，将当前节点排在它后面
//GC会将这些CANCELLED节点回收 do { node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } else {
//将前置节点的状态修改为SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false; }
//通过LockSupport挂起线程，等待唤醒 private final boolean parkAndCheckInterrupt() { LockSupport.park(this); return Thread.interrupted(); }
二.释放锁操作
有了获取锁的基础，再来看释放锁的源码就比较容易了，下面的代码执行的是AQS中释放锁的操作：
//释放锁的操作
public final boolean release(int arg)
//尝试释放锁，这里tryRelease同样由子类实现，如果失败直接返回false if (tryRelease(arg)) { Node h = head; if (h != null && h.waitStatus != 0) unparkSuccessor(h); return true; } return false; }
下面的代码是尝试释放锁的操作：
protected final boolean tryRelease(int releases) {
//获取state值，释放一定值 int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false;
//如果差是0，表示锁已经完全释放 if (c == 0) { free = true;
//下面设置为null表示当前没有线程占用锁 setExclusiveOwnerThread(null); }
//如果c不是0表示锁还没有完全释放，修改state值 setState(c); return free; }
释放锁后，还需要唤醒队列中的一个后继节点：
private void unparkSuccessor(Node node) { //将当前节点的状态修改为0 int ws = node.waitStatus; if (ws < 0) compareAndSetWaitStatus(node, ws, 0); //从队列里找出下一个需要唤醒的节点
//首先是直接后继 Node s = node.next;
//如果直接后继为空或者它的waitStatus大于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); }
