深入分析同步工具类之CountDownLatch

概览：

CountDownLatch又称闭锁，其作用是让一个或者多个线程挂起，直到其他的线程执行完后恢复挂起的线程，使其继续执行。内部维护着一个静态内部类Sync，该类继承AbstractQueuedSynchronizer（这个类之前分析过了，参见    深入分析同步工具类之AbstractQueuedSynchronizer），Sync实例维护着state属性，调用await()方法，使当前线程挂起，当一个线程执行完后，调用countDown()方法，state-1，直到state变为0，被挂起的线程恢复执行。

常用的方法：

public CountDownLatch(int count) //构造函数初始化state值，可以理解为需要优先执行的线程数量

public void await() //调用后，所在的线程挂起

public void countDown() //优先执行的线程执行完调用，state-1，当state=0，执行阻塞队列中的线程

使用实例：

主线程和线程池中的一个线程会被挂起，等线程池中的另外5个线程执行完才会被执行

 CountDownLatch latch=new CountDownLatch(5);

        ExecutorService service= Executors.newFixedThreadPool(6);
        for (int i=0;i<5;i++){
            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(5000);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    latch.countDown();
                }
            });
        }
        service.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    latch.await();
                    System.out.println(Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        latch.await();
        System.out.println("主线程");

运行结果：

代码分析：

 1.await()

//线程等待
public void await() throws InterruptedException {
        //AQS的实现
        sync.acquireSharedInterruptibly(1);
    }

public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
       //尝试获取状态，<0优先执行的线程未执行完，>0已执行完
       //Sync子类自己实现
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

//获取AQS的state值，我们调用countDown会改变这个值
protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        //向队列中添加一个共享节点
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                //该节点的前驱节点
                final Node p = node.predecessor();
                //前驱是头节点
                if (p == head) {
                    //获取状态值
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        //设置节点为头节点，退出循环
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                //否则当前线程挂起
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

addWaiter

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure

        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //第一个节点添加队列时，头节点和尾节点都为空，需要初始化
        enq(node);
        return node;
    }

 private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
               //CAS设置头节点
                if (compareAndSetHead(new Node()))
               //头节点赋值给tail，此时head和tail指向同一个对象，如果对任何一个对象中的属性做修改，那么2个引用的属性也会跟着变(后面挂起线程的时候会修改waitStatus属性)
                    tail = head;
            } else {
                node.prev = t;
                //设置尾节点为当前结点，将2个节点串起来，即：node.prev = t;t.next = node;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;//退出循环
                }
            }
        }
    }
//注意：这里新生成的head节点并没有后继节点 head.next==null,并且head==node.prev(该node是第一次插入的节点) 这个特性在countDown的时候会使用到

假设线程A和线程B先后调用await()方法，并且tryAcquireShared(int acquires)<0,那么此时线程A、B分别被挂起，线程A和B在挂起时先后调用shouldParkAfterFailedAcquire方法，这样各自前驱节点的waitStatus就会被设置为-1，代表该线程需要执行；同时因为线程A的前驱和head引用同一个对象，

所以head==Node并且其waitStatus都为-1

此时队列的节点如下图：

调用挂起线程的方法：

//挂起线程前先将该节点的前驱节点的waitStatus设为-1，即表示其后继节点代表的线程需要执行，这样上图Node B的前驱Node的waitStatus==-1，
因为Node在初始化的时候和head同引用一个对象，所以head 的waitStatus也为-1
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
//挂起前程
private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

此时，若优先执行的线程执行完毕，调用countDown方法，更新state的值，也就是state==0的时候，就会恢复头节点的下一个节点所代表的线程

public void countDown() {
        sync.releaseShared(1);
    }
public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                   //最后一个线程执行完，返回true
                    return nextc == 0;
            }
        }

private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {//true
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    //恢复后继节点代表的线程
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }
private void unparkSuccessor(Node node) {

        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

      //此时s==null，从尾节点开始找到最前面的节点(Node A),将其恢复
        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);
    }

这个时候线程A开始运行，若未发生线程中断，则继续执行循环内的代码，p==head成立，此时获取状态成功，恢复后继节点代表的线程，并退出循环：

        for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
              ...
            }

private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        //设置当前结点为头节点
        setHead(node);

        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {

            Node s = node.next;
            if (s == null || s.isShared())
                //恢复后继节点的线程
                doReleaseShared();
        }
    }

最后，线程B运行 获取状态，退出循环，程序结束