Java队列同步器

队列同步器AbstractQueuedSynchronizer(AQS)，似乎我们不经常用，但是它是用来构建锁或者其他同步组件的基础框架，它使用了一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。对于锁来说，获取到同步状态就表示获取到了该锁。

同步器的主要使用方式是继承，一般作为同步器组件的静态内部类，在同步器中仅定义了与状态相关的方法，且这个状态既可以独占地获取又可以共享的获取，这样就可以实现不同类型的同步组件（ReetrantLock、ReetrantReadWriteLock和CountDownLatch等）。同步器是同步组件实现锁的关键，我们通常使用同步组件来实现各种锁的功能，而其内部实际上是利用同步器进行锁的实现。它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。

以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。

再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS减1。等到所有子线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock

1 同步队列

队列同步器的实现依赖内部的同步队列来完成同步状态的管理。它是一个FIFO的双向队列，当线程获取同步状态失败时，同步器会将当前线程和等待状态等信息包装成一个节点并将其加入同步队列，同时会阻塞当前线程。当同步状态释放时，会把首节点的后继节点的线程唤醒，使其再次尝试获取同步状态。等待队列的头节点head和尾节点head，都是通过volatile修饰，保证了多线程之间的可见。

下面是Node静态内部类的源码：

static final class Node {  
        /** 标识一个这个节点是否为shared类型 */  
        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;  
        /** 
         * waitStatus value to indicate the next acquireShared should 
         * unconditionally propagate 
         */  
        static final int PROPAGATE = -3;  

        volatile int waitStatus;  

        /** 
         * 前驱节点，当节点加入同步队列时被设置 
         */  
        volatile Node prev;  

         /** 
         * 后继节点 
         */  
        volatile Node next;  

        /** 
         * 获取状态状态的线程 
         */  
        volatile Thread thread;  

         /** 
         * 等待队列中的后继节点。如果当前节点是共享的，那么这个字段是一个shared常量， 
         * 也就是说节点类型（独占或共享）和等待队列中个后继节点共用同一个字段 
         */  
        Node nextWaiter;  

        /** 
         * Returns true if node is waiting in shared mode. 
         */  
        final boolean isShared() {  
            return nextWaiter == SHARED;  
        }  

        /** 
         * Returns previous node, or throws NullPointerException if null. 
         * Use when predecessor cannot be null.  The null check could 
         * be elided, but is present to help the VM. 
         * 
         * @return the predecessor of this node 
         */  
        final Node predecessor() throws NullPointerException {  
            Node p = prev;  
            if (p == null)  
                throw new NullPointerException();  
            else  
                return p;  
        }  

        Node() {    // Used to establish initial head or SHARED marker  
        }  

        Node(Thread thread, Node mode) {     // Used by addWaiter  
            this.nextWaiter = mode;  
            this.thread = thread;  
        }  

        Node(Thread thread, int waitStatus) { // Used by Condition  
            this.waitStatus = waitStatus;  
            this.thread = thread;  
        }  
    }  

2 三个核心方法

以下三个方法是与同步状态有关的方法，重写同步器指定的方法时，需要使用同步器提供的如下3个方法来获取或修改同步状态

• getState():获取当前同步状态
• setState(int newState):设置当前同步状态
• compareAndSetState(int expect,int update):使用CAS设置当前状态，该方法能保证状态设置的原子性。

节点是构成同步队列的基础，同步器拥有首节点和尾节点，没有成功获取同步状态的线程会成为节点加入该队列的尾部，其结构如下图所示：

同步器包含了两个节点类型的引用，一个指向头节点，而另一个指向尾节点。如果一个线程没有获得同步队列，那么包装它的节点将被加入到队尾，显然这个过程应该是线程安全的。因此同步器提供了一个基于CAS的设置尾节点的方法：compareAndSetTail(Node expect,Node update),它需要传递一个它认为的尾节点和当前节点，只有设置成功，当前节点才被加入队尾。

同步队列遵循FIFO，首节点是获取同步状态成功的节点，首节点线程在释放同步状态时，将会唤醒后继节点，而后继节点将会在获取同步状态成功时将自己设置为首节点。

3 独占模式获取锁操作

在将Node节点插入到尾部之后，并不是立即挂起该节点中线程，因为在插入它的过程中，前面的线程可能已经执行完成，所以它会先进行自旋操作acquireQueued(node, arg)，尝试让该线程重新获取锁！当条件满足获取到了锁则可以从自旋过程中退出，否则继续。

如果没获取到锁，则判断是否应该挂起，而这个判断通过它的前驱节点的waitStatus来确定。如果前驱节点的waitStatus为：

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            return true;
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

• SIGNAL，则返回true表示应该挂起当前线程。挂起该线程，并等待被唤醒，被唤醒后进行中断检测，如果发现当前线程被中断，那么抛出InterruptedException并退出循环。
• 大于0（CANCELLED）：前驱节点踢出队列，返回false
• 小于0（CONDITION/PROPAGATE）：也是返回false，不过先将前驱节点waitStatus设置为SIGNAL，使得下次判断时，将当前节点挂起。

总结：

AQS的模板方法acquire通过调用子类自定义实现的tryAcquire获取同步状态失败后，将线程构造成Node节点，将Node节点添加到同步队列对尾，节点以自旋的方法获取同步状态(acquirQueued)。在节点自旋获取同步状态时，只有其前驱节点是头节点的时候才会尝试获取同步状态，如果该节点的前驱不是头节点或者该节点的前驱节点是头节点但获取同步状态失败，则判断当前线程是否需要阻塞，如果需要阻塞则在被唤醒过后才返回。

4 独占模式释放锁操作

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}
/**如果node的后继节点不为空且不是作废状态,则唤醒这个后继节点,否则从末尾开始寻找合适的节点,如果找到,则唤醒*/
private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    Node s = node.next;
    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);
}

首先调用子类的tryRelease()方法释放锁，然后唤醒后继节点，在唤醒的过程中，需要判断后继节点是否满足情况，如果后继节点不是作废状态，则唤醒这个后继节点，否则从tail节点向前寻找合适的节点，如果找到，则唤醒之。

5 共享模式获取或释放

acquireShared(int)

此方法是共享模式下线程获取共享资源的顶层入口。它会获取指定量的资源，获取成功则直接返回，获取失败则进入等待队列，直到获取到资源为止，整个过程忽略中断。下面是acquireShared()的源码：

public final void acquireShared(int arg) {
     if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

这里tryAcquireShared()依然需要自定义同步器去实现。但是AQS已经把其返回值的语义定义好了：负值代表获取失败；0代表获取成功，但没有剩余资源；正数表示获取成功，还有剩余资源，其他线程还可以去获取。所以这里acquireShared()的流程就是：

• tryAcquireShared()尝试获取资源，成功则直接返回；
• 失败则通过doAcquireShared()进入等待队列，直到获取到资源为止才返回。

doAcquireShared(int)

此方法用于将当前线程加入等待队列尾部休息，直到其他线程释放资源唤醒自己，自己成功拿到相应量的资源后才返回。下面是doAcquireShared()的源码：

private void doAcquireShared(int arg) {
    final Node node = addWaiter(Node.SHARED);//加入队列尾部
    boolean failed = true;//是否成功标志
    try {
        boolean interrupted = false;//等待过程中是否被中断过的标志
        for (;;) {
            final Node p = node.predecessor();//前驱
            if (p == head) {//如果到head的下一个，因为head是拿到资源的线程，此时node被唤醒，很可能是head用完资源来唤醒自己的
                int r = tryAcquireShared(arg);//尝试获取资源
                if (r >= 0) {//成功
                    setHeadAndPropagate(node, r);//将head指向自己，还有剩余资源可以再唤醒之后的线程
                    p.next = null; // help GC
                    if (interrupted)//如果等待过程中被打断过，此时将中断补上。
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }

            //判断状态，寻找安全点，进入waiting状态，等着被unpark()或interrupt()
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

跟独占模式比，还有一点需要注意的是，这里只有线程是head.next时（“老二”），才会去尝试获取资源，有剩余的话还会唤醒之后的队友。那么问题就来了，假如老大用完后释放了5个资源，而老二需要6个，老三需要1个，老四需要2个。老大先唤醒老二，老二一看资源不够，他是把资源让给老三呢，还是不让？答案是否定的！老二会继续park()等待其他线程释放资源，也更不会去唤醒老三和老四了。独占模式，同一时刻只有一个线程去执行，这样做未尝不可；但共享模式下，多个线程是可以同时执行的，现在因为老二的资源需求量大，而把后面量小的老三和老四也都卡住了。当然，这并不是问题，只是AQS保证严格按照入队顺序唤醒罢了（保证公平，但降低了并发）。

setHeadAndPropagate(Node, int)

private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; 
    setHead(node);//head指向自己
     //如果还有剩余量，继续唤醒下一个邻居线程
    if (propagate > 0 || h == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

此方法在setHead()的基础上多了一步，就是自己苏醒的同时，如果条件符合（比如还有剩余资源），还会去唤醒后继结点。

总结：

• tryAcquireShared()尝试获取资源，成功则直接返回；
• 失败则通过doAcquireShared()进入等待队列park()，直到被unpark()/interrupt()并成功获取到资源才返回。整个等待过程也是忽略中断的。
• 其实跟acquire()的流程大同小异，只不过多了个自己拿到资源后，还会去唤醒后继队友的操作（这才是共享嘛）。

releaseShared()

上一小节已经把acquireShared()说完了，这一小节就来讲讲它的反操作releaseShared()吧。此方法是共享模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果成功释放且允许唤醒等待线程，它会唤醒等待队列里的其他线程来获取资源。下面是releaseShared()的源码：

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {//尝试释放资源
        doReleaseShared();//唤醒后继结点
        return true;
    }
    return false;
}

此方法的流程也比较简单，一句话：释放掉资源后，唤醒后继。跟独占模式下的release()相似，但有一点稍微需要注意：独占模式下的tryRelease()在完全释放掉资源（state=0）后，才会返回true去唤醒其他线程，这主要是基于独占下可重入的考量；而共享模式下的releaseShared()则没有这种要求，共享模式实质就是控制一定量的线程并发执行，那么拥有资源的线程在释放掉部分资源时就可以唤醒后继等待结点。例如，资源总量是13，A（5）和B（7）分别获取到资源并发运行，C（4）来时只剩1个资源就需要等待。A在运行过程中释放掉2个资源量，然后tryReleaseShared(2)返回true唤醒C，C一看只有3个仍不够继续等待；随后B又释放2个，tryReleaseShared(2)返回true唤醒C，C一看有5个够自己用了，然后C就可以跟A和B一起运行。而ReentrantReadWriteLock读锁的tryReleaseShared()只有在完全释放掉资源（state=0）才返回true，所以自定义同步器可以根据需要决定tryReleaseShared()的返回值。

6 Mutex（互斥锁）

Mutex是一个不可重入的互斥锁实现。锁资源（AQS里的state）只有两种状态：0表示未锁定，1表示锁定。下边是Mutex的核心源码：

class Mutex implements Lock, java.io.Serializable {
    // 自定义同步器
    private static class Sync extends AbstractQueuedSynchronizer {
        // 判断是否锁定状态
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

        // 尝试获取资源，立即返回。成功则返回true，否则false。
        public boolean tryAcquire(int acquires) {
            assert acquires == 1; // 这里限定只能为1个量
            if (compareAndSetState(0, 1)) {//state为0才设置为1，不可重入！
                setExclusiveOwnerThread(Thread.currentThread());//设置为当前线程独占资源
                return true;
            }
            return false;
        }

        // 尝试释放资源，立即返回。成功则为true，否则false。
        protected boolean tryRelease(int releases) {
            assert releases == 1; // 限定为1个量
            if (getState() == 0)//既然来释放，那肯定就是已占有状态了。只是为了保险，多层判断！
                throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);//释放资源，放弃占有状态
            return true;
        }
    }

    // 真正同步类的实现都依赖继承于AQS的自定义同步器！
    private final Sync sync = new Sync();

    //lock<-->acquire。两者语义一样：获取资源，即便等待，直到成功才返回。
    public void lock() {
        sync.acquire(1);
    }

    //tryLock<-->tryAcquire。两者语义一样：尝试获取资源，要求立即返回。成功则为true，失败则为false。
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    //unlock<-->release。两者语文一样：释放资源。
    public void unlock() {
        sync.release(1);
    }

    //锁是否占有状态
    public boolean isLocked() {
        return sync.isHeldExclusively();
    }
}

---

7 读写锁

读写锁维护了一对锁，一个读锁，一个写锁，通过分离读锁和写锁提高性能。特别需要注意的是读写锁中的锁降级。

我们知道写锁是排他锁，读锁是共享锁。但是一个线程如果已经获得了写锁，那么它再去获取读锁是一定可以获取得到的。我们将把持住写锁 —> 获取读锁 —>释放写锁这个过程称之为锁降级。

但是我们不支持锁升级：把持住读锁 —> 获取写锁 —>释放读锁。因为读锁是共享锁，所以同一时刻持有读锁的线程可能不止一个，其中任意线程如果获取到了写锁并更新了数据，其他已经获取了读锁的线程不会被阻塞等待，直接读取的可能会是脏数据。

---

8 Condition接口

• Object监视器：有一个同步队列和一个等待队列；
• Lock：有一个同步队列和多个Condition等待队列；

如果一个线程调用了Condition.await()方法，则：

（1）释放锁；

（2）构造成节点加入到等待队列的尾部；

（3）线程阻塞；

相当于同步队列的首节点移动到了Condition队列的队尾。