Java并发系列[1]----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提供了一把密码锁？

 1 //同步队列的头结点
 2 private transient volatile Node head; 
 3 
 4 //同步队列的尾结点
 5 private transient volatile Node tail;
 6 
 7 //同步状态
 8 private volatile int state;
 9 
10 //获取同步状态
11 protected final int getState() {
12     return state;
13 }
14 
15 //设置同步状态
16 protected final void setState(int newState) {
17     state = newState;
18 }
19 
20 //以CAS方式设置同步状态
21 protected final boolean compareAndSetState(int expect, int update) {
22     return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
23 }

上面的代码列出了AQS的全部成员变量，能够看到AQS的成员变量只有三个，分别是同步队列头结点引用，同步队列尾结点引用以及同步状态。注意，这三个成员变量都使用了volatile关键字进行修饰，这就确保了多个线程对它的修改都是内存可见的。整个类的核心就是这个同步状态，能够看到同步状态其实就是一个int型的变量，你们能够把这个同步状态当作一个密码锁，并且仍是从房间里面锁起来的密码锁，state具体的值就至关于密码控制着密码锁的开合。固然这个锁的密码是多少就由各个子类来规定了，例如在ReentrantLock中，state等于0表示锁是开的，state大于0表示锁是锁着的，而在Semaphore中，state大于0表示锁是开的，state等于0表示锁是锁着的。

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

AbstractQueuedSynchronizer内部其实有两个排队区，一个是同步队列，一个是条件队列。从上图能够看出，同步队列只有一条，而条件队列能够有多条。同步队列的结点分别持有先后结点的引用，而条件队列的结点只有一个指向后继结点的引用。图中T表示线程，每一个结点包含一个线程，线程在获取锁失败后首先进入同步队列排队，而想要进入条件队列该线程必须持有锁才行。接下来咱们看看队列中每一个结点的结构。

 1 //同步队列的结点
 2 static final class Node {
 3     
 4     static final Node SHARED = new Node(); //表示当前线程以共享模式持有锁
 5     
 6     static final Node EXCLUSIVE = null;    //表示当前线程以独占模式持有锁
 7 
 8     static final int CANCELLED =  1;       //表示当前结点已经取消获取锁
 9     
10     static final int SIGNAL    = -1;       //表示后继结点的线程须要运行
11     
12     static final int CONDITION = -2;       //表示当前结点在条件队列中排队
13     
14     static final int PROPAGATE = -3;       //表示后继结点能够直接获取锁
15 
16     volatile int waitStatus; //表示当前结点的等待状态
17    
18     volatile Node prev;      //表示同步队列中的前继结点
19 
20     volatile Node next;      //表示同步队列中的后继结点  
21 
22     volatile Thread thread;  //当前结点持有的线程引用
23     
24     Node nextWaiter;         //表示条件队列中的后继结点
25 
26     //当前结点状态是不是共享模式
27     final boolean isShared() {
28         return nextWaiter == SHARED;
29     }
30 
31     //返回当前结点的前继结点
32     final Node predecessor() throws NullPointerException {
33         Node p = prev;
34         if (p == null) {
35             throw new NullPointerException();
36         } else {
37             return p;
38         }
39     }
40     
41     //构造器1
42     Node() {}
43     
44     //构造器2, 默认用这个构造器
45     Node(Thread thread, Node mode) {
46         //注意持有模式是赋值给nextWaiter
47         this.nextWaiter = mode;
48         this.thread = thread;
49     }
50     
51     //构造器3, 只在条件队列中用到
52     Node(Thread thread, int waitStatus) {
53         this.waitStatus = waitStatus;
54         this.thread = thread;
55     }
56 }

Node表明同步队列和条件队列中的一个结点，它是AbstractQueuedSynchronizer的内部类。Node有不少属性，好比持有模式，等待状态，同步队列中的前继和后继，以及条件队列中的后继引用等等。能够把同步队列和条件队列当作是排队区，每一个结点当作是排队区的座位，将线程当作是排队的客人。客人刚来时会先去敲敲门，看看锁有没有开，若是锁没开它就会去排队区领取一个号码牌，声明本身想要以什么样的方式来持有锁，最后再到队列的末尾进行排队。

3. 怎样理解独占模式和共享模式？

前面讲到每一个客人在排队前会领取一个号码牌，声明本身想要以什么样的方式来占有锁，占有锁的方式分为独占模式和共享模式，那么怎样来理解独占模式和共享模式呢？实在找不到什么好的比喻，你们能够联想一下公共厕所，独占模式的人比较霸道，老子要么就不进，进来了就不准别人再进了，本身一我的独自占用整个厕所。共享模式的人就没那么讲究了，当它发现这个厕所已经能够用了以后，它本身进来还不算，还得热心的问下后面的人介不介意一块儿用，若是后面的人不介意一块儿使用那就不用再排队了你们一块儿上就是了， 固然若是后面的人介意那就只好留在队列里继续排队了。

4. 怎样理解结点的等待状态？

咱们还看到每一个结点都有一个等待状态，这个等待状态分为CANCELLED，SIGNAL，CONDITION，PROPAGATE四种状态。能够将这个等待状态看做是挂在座位旁边的牌子，标识当前座位上的人的等待状态。这个牌子的状态不只本身能够修改，其余人也能够修改。例如当这个线程在排队过程当中已经打算放弃了，它就会将本身座位上的牌子设置为CANCELLED，这样其余人看到了就能够将它清理出队列。还有一种状况是，当线程在座位上要睡着以前，它怕本身睡过了头，就会将前面位置上的牌子改成SIGNAL，由于每一个人在离开队列前都会回到本身座位上看一眼，若是看到牌子上状态为SIGNAL，它就会去唤醒下一我的。只有保证前面位置上的牌子为SIGNAL，当前线程才会安心的睡去。CONDITION状态表示该线程在条件队列中排队，PROPAGATE状态提醒后面来的线程能够直接获取锁，这个状态只在共享模式用到，后面单独讲共享模式的时候会讲到。

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

 1 //结点入队操做, 返回前一个结点
 2 private Node enq(final Node node) {
 3     for (;;) {
 4         //获取同步队列尾结点引用
 5         Node t = tail;
 6         //若是尾结点为空说明同步队列尚未初始化
 7         if (t == null) {
 8             //初始化同步队列
 9             if (compareAndSetHead(new Node())) {
10                 tail = head;
11             }
12         } else {
13             //1.指向当前尾结点
14             node.prev = t;
15             //2.设置当前结点为尾结点
16             if (compareAndSetTail(t, node)) {
17                 //3.将旧的尾结点的后继指向新的尾结点
18                 t.next = node;
19                 //for循环惟一的出口
20                 return t;
21             }
22         }
23     }
24 }

注意，入队操做使用一个死循环，只有成功将结点添加到同步队列尾部才会返回，返回结果是同步队列原先的尾结点。下图演示了整个操做过程。

读者须要注意添加尾结点的顺序，分为三步：指向尾结点，CAS更改尾结点，将旧尾结点的后继指向当前结点。在并发环境中这三步操做不必定能保证完成，因此在清空同步队列全部已取消的结点这一操做中，为了寻找非取消状态的结点，不是从前向后遍历而是从后向前遍历的。还有就是每一个结点进入队列中时它的等待状态是为0，只有后继结点的线程须要挂起时才会将前面结点的等待状态改成SIGNAL。

注：以上所有分析基于JDK1.7，不一样版本间会有差别，读者须要注意