AbstractQueuedSynchronizer源码分析之概要

学习Java并发编程不得不去了解一下java.util.concurrent这个包，这个包下面有许多我们经常用到的并发工具类，例如：ReentrantLock, CountDownLatch, CyclicBarrier, Semaphore等。而这些类的底层实现都依赖于AbstractQueuedSynchronizer这个类，由此可见这个类的重要性。

所以在Java并发系列文章中我首先对AbstractQueuedSynchronizer这个类进行分析，由于这个类比较重要，而且代码比较长，为了尽可能分析的透彻一些，我决定用四篇文章对该类进行一个比较完整的介绍。本篇文章作为概要介绍主要是让读者们对该类有个初步了解。为了叙述简单，后续有些地方会用AQS代表这个类。

1. AbstractQueuedSynchronizer这个类是干嘛的？

相信要许多读者使用过ReentrantLock，但是却不知道AbstractQueuedSynchronizer的存在。其实ReentrantLock实现了一个内部类Sync，该内部类继承了AbstractQueuedSynchronizer，所有锁机制的实现都是依赖于Sync内部类，也可以说ReentrantLock的实现就是依赖于AbstractQueuedSynchronizer类。于此类似，CountDownLatch, CyclicBarrier, Semaphore这些类也是采用同样的方式来实现自己对于锁的控制。

可见，AbstractQueuedSynchronizer是这些类的基石。那么AQS内部到底实现了什么以至于所以这些类都要依赖于它呢？可以这样说，AQS为这些类提供了基础设施，也就是提供了一个密码锁，这些类拥有了密码锁之后可以自己来设置密码锁的密码。

此外，AQS还提供了一个排队区，并且提供了一个线程训导员，我们知道线程就像一个原始的野蛮人，它不懂得讲礼貌，它只会横冲直撞，所以你得一步一步去教它，告诉它什么时候需要去排队了，要到哪里去排队，排队前要做些什么，排队后要做些什么。这些教化工作全部都由AQS帮你完成了，从它这里教化出来的线程都变的非常文明懂礼貌，不再是原始的野蛮人，所以以后我们只需要和这些文明的线程打交道就行了，千万不要和原始线程有过多的接触！

2. 为何说AbstractQueuedSynchronizer提供了一把密码锁？

//同步队列的头结点
private transient volatile Node head; 

//同步队列的尾结点
private transient volatile Node tail;

//同步状态
private volatile int state;

//获取同步状态
protected final int getState() {
   return state;
}

//设置同步状态
protected final void setState(int newState) {
   state = newState;
}

//以CAS方式设置同步状态
protected final boolean compareAndSetState(int expect, int update) {
   return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
 

上面的代码列出了AQS的所有成员变量，可以看到AQS的成员变量只有三个，分别是同步队列头结点引用，同步队列尾结点引用以及同步状态。

注意，这三个成员变量都使用了volatile关键字进行修饰，这就确保了多个线程对它的修改都是内存可见的。整个类的核心就是这个同步状态，可以看到同步状态其实就是一个int型的变量，大家可以把这个同步状态看成一个密码锁，而且还是从房间里面锁起来的密码锁，state具体的值就相当于密码控制着密码锁的开合。当然这个锁的密码是多少就由各个子类来规定了，例如在ReentrantLock中，state等于0表示锁是开的，state大于0表示锁是锁着的，而在Semaphore中，state大于0表示锁是开的，state等于0表示锁是锁着的。

 

3. AbstractQueuedSynchronizer的排队区是怎样实现的？

 

AbstractQueuedSynchronizer内部其实有两个排队区，一个是同步队列，一个是条件队列。从上图可以看出，同步队列只有一条，而条件队列可以有多条。同步队列的结点分别持有前后结点的引用，而条件队列的结点只有一个指向后继结点的引用。

图中T表示线程，每个结点包含一个线程，线程在获取锁失败后首先进入同步队列排队，而想要进入条件队列该线程必须持有锁才行。接下来我们看看队列中每个结点的结构。

 

    static final class Node {
        //表示当前线程以共享模式持有锁
        static final Node SHARED = new Node();
        //表示当前线程以独占模式持有锁
        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;
        /**
         * waitStatus value to indicate the next acquireShared should
         * unconditionally propagate
         */
        //表示后继结点可以直接获取锁
        static final int PROPAGATE = -3;
      
        //表示当前结点的等待状态
        volatile int waitStatus;

        //表示同步队列中的前继结点
        volatile Node prev;

     
        //当前结点持有的线程引用
        volatile Thread thread;

        //表示条件队列中的后继结点
        Node nextWaiter;

        /**
         * Returns true if node is waiting in shared mode.
         */
        //当前结点状态是否是共享模式
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        //返回当前结点的前继结点
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
        //构造器1
        Node() {    // Used to establish initial head or SHARED marker
        }
        //构造器2, 默认用这个构造器
        Node(Thread thread, Node mode) {     // Used by addWaiter
            //注意持有模式是赋值给nextWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }
        //构造器3, 只在条件队列中用到
        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

4.结点进入同步队列时会进行哪些操作？

/**
 * Inserts node into queue, initializing if necessary. See picture above.
 * @param node the node to insert
 * @return node's predecessor
 * 结点入队操作, 返回前一个结点
 * 注意，入队操作使用一个死循环，只有成功将结点添加到同步队列尾部才会返回，返回结果是同步队列原先的尾结点。
 * 读者需要注意添加尾结点的顺序，分为三步：指向尾结点，CAS更改尾结点，将旧尾结点的后继指向当前结点。
 * 在并发环境中这三步操作不一定能保证完成，所以在清空同步队列所有已取消的结点这一操作中，为了寻找非取消状态的结点，
 * 不是从前向后遍历而是从后向前遍历的。还有就是每个结点进入队列中时它的等待状态是为0，只有后继结点的线程需要挂起时才会将前面结点的等待状态改为SIGNAL。
 */
private Node enq(final Node node) {
    for (;;) {
        //获取同步队列尾结点引用
        Node t = tail;
        //如果尾结点为空说明同步队列还没有初始化
        if (t == null) { // Must initialize
            //初始化同步队列
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //1.指向当前尾结点
            node.prev = t;
            //2.CAS更改尾结点
            if (compareAndSetTail(t, node)) {
                //3.将旧尾结点的后继指向当前结点
                t.next = node;
                //for循环唯一的出口
                return t;
            }
        }
    }
}

 

 参考：