java并发之AbstractQueuedSynchronizer （1）

java并发编程必须了解的一个包java.util.concurrent,我们经常用到的并发工具类，例如：Reentrantlock,CountDownLatch,Semaphore等。这些类的底层都依赖于AbstractQueuedSynchronizer这个类。

1.AbstractQueuedSynchronizer 作用

Reentrantlock,CountDownLatch,Semaphore等都实现了内部类Sync，该类继承了		AbstractQueuedSynchronizer类，所有锁机制都依赖于Sync内部类。
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的排队区是怎样实现的？

AQS内部有两个排队区，一个是同步队列，一个是条件队列。同步队列只能有一条，而条件队列可以有多条。同步队列的节点分别持有前后节点的引用，而条件队列的节点只有一个指向后继结点的引用。

上图中T代表线程，每个结点包含一个线程，线程获取锁失败后首先进入同步队列排队，进入条件队列的线程都已经持有锁，接下来看看队列中每个节点的结构。

static final class Node{
        static final Node SHARED = new Node();
        //表示当前线程以共享模式持有锁

        static final Node EXCLUSIVE = null;
        //表示当前线程以独占模式持有锁

        static final int CANCELLED = 1;
        //表示当前线程已经取消获取锁

        static final int SIGNAL = -1;
        //表示后继节点的线程需要运行

        static final int CONDITION = -2;
        //表示当前节点在条件队列中排队

        static final int PROPAGATE = -3;
        //表示后继节点可以直接获取锁

        volatile int waitStatus;
        //表示当前结点的等待状态

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

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

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

        //当前结点状态是否是共享模式
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        //返回当前结点的前继结点
        final Node predecsssor() throws NullPointerException {
            Node p = prev;
            if (p == null) {
                throw new NullPointerException();
            } else {
                return p;
            }
        }

        //构造器1
        Node() {
        }

        //构造器2，默认使用此构造器
        Node(Thread thread, Node mode) {
            //注意持有模式是赋值给nextWait
            this.nextWaiter = mode;
            this.thread = thread;
        }

        //构造器3，只能在条件队列中用到
        Node(Thread thread, int waitStatus) {
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

Node代表同步队列和条件队列中的一个结点，它是AbstractQueuedSynchronizer的内部类，Node有很多属性，比如持有模式，等待状态，同步队列中的前继和后继，以及条件队列中的后继引用等等。

可以把同步队列和条件队列看成是排队区，每个节点看成是排队区的座位，将线程看成是排队的客人。
客人刚来会先敲门，看锁有没有开，如果锁没开他就会去排队区领取一个号码牌，声明自己想要以什么样的方式来持有锁，最后再到队列的末尾进行排队。

4.独占模式和共享模式

独占模式通俗的说就是，一个房间要么我不进，如果我进去了别人就都不能进。

共享模式的人是，我进来了之后问下后面的人要不要进来，后面的人如果愿意就一起进来，如果后面的人不想进来就会继续排队。

5.结点的等待状态

每个结点都有一个等待状态，这个等待状态分为CANCELLED,SIGNAL,CONDITION,PROPAGATE四种状态。 可以将这个等待状态看作是挂在座位上的牌子，标识当前座位上的人得等待状态，这个牌子的状态不进自己可以修改，其他人也可以修改。 如果这个线程在排队过程中打算放弃了，就会将自己座位上的牌子设置为CANCELLED,这样其他人看到了就可以将
它清理出队列。 还有一种情况是，当线程在座位上要睡着之前，它怕自己睡过了头，就会将前面位置上的牌子改为SIGNAL,因为每个人在离开时都会看一眼，如果牌子上状态为
SIGNAL, //它就会去唤醒下一个人，只有保证前面位置上的牌子为SIGNAL,当前线程才会安心的睡去。 CONDITION状态表示该线程在条件队列中排队，PROPAGATE状态提醒后面来的线程可以直接获取锁，这个状态只在共享模式用到。

6.结点进入同步队列进行 操作

  //结点入队操作，返回前一个结点
    private Node enq(final Node node) {
        for (; ; ) {
            //获取同步队列尾结点引用
            Node t = tail;
            //如果尾结点为空说明同步队列还没有初始化
            if (t == null) {
                //初始化同步队列
                if (compareAndSetHead(new Node())) {
                    tail = head;
                }
            } else {
                //1.指向当前尾结点
                node.prev = t;
                //2.设置当前结点为尾结点
                if (compareAndSetTail(t, node)) {
                    //3.将旧的尾结点的后继指向新的尾结点
                    t.next = node;
                    //for循环唯一的出口
                    return t;
                }
            }
        }
    }

注意，入队操作使用一个死循环，只有成功将结点添加到同步队列尾部才会返回，返回结果是同步队列原先的尾结点。

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