AQS之CountDownLatch

目录

await

countDown

流程总结

---

CountDownLatch是java并发包中一个常见的类，本文将从源码的角度来分析CountDownLatch的实现原理，而CountDownLatch是基于AQS的共享锁模式来实现的，所以需要对AQS有一定的了解。关于AQS可参考前两篇文章：AQS之ReentrantLock 、AQS之Condition

CountDownLatch的实用性很强，可以把它理解为计数器，通过构造方法new CountDownLatch(N)传入要执行的任务数N，有多个线程去执行这N个任务，每个线程调用一次countDown()就代表完成了一个任务，计数器-1，而线程调用了await()方法后，则会阻塞在那里，直到计数器减为0，代表任务全部完成。这个时候阻塞的线程就可以继续执行。

下面来看一下CountDownLatch源码分析，老规矩先看下它的构造方法

    // 传入count，指定任务个数
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
        // 内部还是依赖于AQS,在这里将AQS的state设置为count
        Sync(int count) {
            setState(count);
        }
    ......
    }

    protected final void setState(int newState) {
        state = newState;
    }

我们前面说过CountDownLatch使用的是AQS的共享模式，它在初始化时就给state设值，所有调用await()方法的线程都会被挂起进入等待，而其他线程会调用countDown()方法对state进行-1操作。当state减到0的时候，所有通过await()挂起的线程都会被唤醒，这个时候await方法才会返回。

await

接下来我们看下await()方法的源码，执行该方法会使线程阻塞，直到state减为0。

    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        // 一进来判断中断状态。响应中断
        if (Thread.interrupted())
            throw new InterruptedException();
        // 如果tryAcquiredShared小于0，执行doAcquireSharedInterruptibly
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }
    // 只有当state为0的时候，这个方法才会返回1
    protected int tryAcquireShared(int acquires) {
        // 获取当前AQS的state，判断是否为0
        // state初始值为CountDownLatch构造方法中传入的N
        return (getState() == 0) ? 1 : -1;
    }  

很明显一开始的时候，state不会为0，所以tryAquiredShared会返回-1，接着往下执行doAcquireSharedInterruptibly(arg)。

    // 这个方法就是在获取共享锁，这里传入的arg为1
    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        // 这里会通过自璇尝试将当前线程加入到AQS队列中，直到成功为止。
        // 返回代表当前线程的node对象，并指定当前节点为共享模式
        // 共享模式其实就是将nextwaiter属性设置为具体的node实例
        // 而且多个线程在共享模式下，它们的nextwaiter都是指向这个node实例  
        // 而独占模式中，它们的nextwaiter是指向null的  
        // 只有在使用Condition的时候，condition队列的nextwaiter会指向它的下一个节点     
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            //注意：这里是自璇操作
            for (;;) {
                // 获取当前node的前一个节点
                final Node p = node.predecessor();
                // 当前节点的前一个节点是head,说明当前节点在等待队列中排在第一个
                if (p == head) {
                    // 只有当state为0的时候，这个方法才会返回1，下一步的r>=0才会成立
                    int r = tryAcquireShared(arg);
                    // 此时还不会进入这个分支的流程
                    if (r >= 0) {
                        // 将当时线程设置为head，然后唤醒队列中后面的线程
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                // 这里判断当前线程是否需要挂起，每个线程进来waitStatus默认为0
                // 这里会将当前线程前节点的waitStatus改为-1，代表当前线程需要被挂起
                // 所以下一轮循环的时候，当前线程前节点的waitStatus就是-1了
                // shouldParkAfterFailedAcquire返回true，跟着执行后面的parkAndCheckInterrupt
                if (shouldParkAfterFailedAcquire(p, node) &&
                    // 挂起当前线程
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

到这一步，假设我们有n个线程执行了await()方法，一开始的时候state不为0，每个线程都会进入到AQS等待(同步）队列，每个线程代表的node会将前一个节点的waitStatus设置为-1，然后挂起，等待唤醒。示意图如下：

countDown

下面我们再来看一下唤醒的过程，CountDownLatch.countDown() 方法

    // 可以看到就是release操作，传入的参数是1，也就是对state进行-1操作
    public void countDown() {
        sync.releaseShared(1);
    }
    
    public final boolean releaseShared(int arg) {
        // 这里对state进行-1操作， 只有state 减为 0 的时候
        // tryReleaseShared才会返回true，往下执行doReleaseShared()
        // 否则tryReleaseShared返回false，这个方法就结束了，直接返回
        if (tryReleaseShared(arg)) {
            // 这一步唤醒通过await挂起的线程
            doReleaseShared();
            return true;
        }
        return false;
    }
    // 使用CAS自旋的方式尝试对state进行-1操作
    protected boolean tryReleaseShared(int releases) {
        // 自旋
        for (;;) {
            int c = getState();
            // 如果当前state已经是0了，直接返回false
            if (c == 0)
                return false;
            int nextc = c-1;
            // 如果state减1成功，并且state减为0了，才会返回true
            if (compareAndSetState(c, nextc))
                return nextc == 0;
        }
    }

每个线程调用countDown的时候，会将state的值减1，总有一个线程会将state的值减为0，然后执行doReleaseShared()唤醒挂起的线程。

    private void doReleaseShared() {
        /*
         * 这里需要自璇，因为在唤醒的过程中可能又有新的线程加入进来，
         * 而且CAS可能会失败
         */
        for (;;) {
            Node h = head;
            // 判断队列是否为空
            if (h != null && h != tail) {
                // 获取头节点的状态
                int ws = h.waitStatus;
                // 我们前面说过线程在入队的时候会将前节点的状态设置为SIGNAL(-1)
                // 所以正常来说会进入这个分支
                if (ws == Node.SIGNAL) {
                    // 将head的waitStatus设置为0
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    // 如果head的waitStatus成功修改为0，唤醒head的下一个节点
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            // 如果执行到这里，head有变化说明线程已经被唤醒
            // 那么进入下一轮循环，否则说明head没变化，退出循环
            if (h == head)                   // loop if head changed
                break;
        }
    }

    //这个方法就是在唤醒head的下一个节点
    private void unparkSuccessor(Node node) {
        //获得head的状态
        int ws = node.waitStatus;
        //如果head的waitStatus小于0，那么这个时候把它置为0
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        //取出head的下一个节点
        Node s = node.next;
        //本来是要唤醒head的下一个节点，但是下一个节点可能已经取消了等待(waitStatus=1)，
        //所以需要找到阻塞队列(不包括head)中waitStatus<0的第一个节点
        if (s == null || s.waitStatus > 0) {
            s = null;
            //从tail开始往前遍历，直到找出waitStatus<0排在等待队列最前面的那个节点
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            //就是在这里唤醒的线程
            LockSupport.unpark(s.thread);
    }

之前我们说n个线程，执行了await()方法，在parkAndCheckInterrupt()这里线程就挂起了，等待被唤醒。现在head的下一个节点被唤醒后，就会继续往下执行，我们再回到parkAndCheckInterrupt()这里。

    // 这个方法就是在获取共享锁，这里传入的arg为1
    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        // 这里会通过自璇尝试将当前线程加入到AQS队列中，直到成功为止。 
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            //注意：这里是自璇操作
            for (;;) {
                // 获取当前node的前一个节点
                final Node p = node.predecessor();
                // 当前节点的前一个节点是head,说明当前节点在等待队列中排在第一个
                if (p == head) {
                    // 只有当state为0的时候，这个方法才会返回1，下一步的r>=0才会成立
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        // 将当时线程设置为head，然后唤醒队列中后面的线程
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                
                if (shouldParkAfterFailedAcquire(p, node) &&
                    // 线程在这里挂起，现在线程被唤醒后,继续往下执行
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

parkAndCheckInterrupt()方法返回，这里如果发生了中断，会抛出中断异常，正常来说，会进入下一轮循环。这个时候status减到0了，head的下一个节点代表的线程会执行setHeadAndPropagate()，占领head，然后唤醒它的下一个节点。

    private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        // 设置head为传入的node
        setHead(node);
        // 下面这一整段其实就是唤醒node的下一个节点
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                // 又是这个方法，其实就是唤醒head的下一个节点，
                // 只不过此时head已经是传入的node了
                doReleaseShared();
        }
    }

也就是说每个线程唤醒后会占领head，然后唤醒它的下一个节点，这样一来。所有await的线程终将被唤醒。整个countDown的流程如下图所示：

流程总结

最后来分析一下整个的流程：

1. new CountDownLatch(N)的时候，初始化了state的值为N。
2. 有n个线程调用了await()方法，加入到AQS等待(同步）队列后就挂起了，等待被唤醒。
3. 然后同时也有其他线程在执行countDown()方法，每次执行countDown()方法会将state减1。
4. 将state减为0的那个线程，会唤醒head的下一个节点。
5. 而每个线程被唤醒后会尝试占领head，继续唤醒它的下一个节点，最终唤醒所有的线程