CountDownLatch源码的理解

设计理念

CountDownLatch对线程的阻塞、释放是基于队列+计数器来实现的。

简单的例子说明

现在有如下代码：

public static void main(String[] args) {    final CountDownLatch latch = new CountDownLatch(2);    new Thread(){        public void run() {            try {                System.out.println("线程1执行");                Thread.sleep(5000);                latch.countDown();            } catch (InterruptedException e) {                e.printStackTrace();            }        };    }.start();    new Thread(){        public void run() {            try {                System.out.println("线程2执行");                Thread.sleep(3000);                latch.countDown();            } catch (InterruptedException e) {                e.printStackTrace();            }        };    }.start();    new Thread(){        public void run() {            try {                System.out.println("线程3阻塞");                latch.await();                System.out.println("线程3继续执行");            } catch (InterruptedException e) {                e.printStackTrace();            }        };    }.start();    try {        Thread.sleep(1000);        System.out.println("主线程线程阻塞");        latch.await();    } catch (InterruptedException e) {        e.printStackTrace();    }    System.out.println("主线程继续执行");}

运行后的效果

线程1执行线程2执行线程3阻塞主线程线程阻塞线程3继续执行主线程继续执行

结果说明：当latch中的计数器变为0时，调用await()的线程会继续执行，继续执行的顺序跟调用await()的先后有关。

队列+计数器的说明

计数器的简单说明

为了简化流程图，假设只有一个子线程调用了countDown()方法，只有主线程调用到了await()方法

上面的流程图只是说明计数器对各个线程的影响，个人不才，实在是画不出多线程+队列的的流程图。

队列的简单说明

每个线程调用await()，会向队列中添加一个node,拿刚才的代码说明：
1. 线程3调用await()，会在head和面添加一个node1(Head是自动生成的)

1. 主线程线程调用await()，会在已有的队列中添加一个node2

1. 当计数器为0，各个线程被唤醒的时候，会判断线程对应node的前一个节点是否是Head，如果是Head，将当前的node设置为Head，再次唤醒线程。如果不是Head，继续挂起。对于上述代码：
   
   • 假如唤醒线程的时候，主线程首先执行：
     
   • 假如唤醒线程的时候，线程3首先执行：
     

以上这些流程图只是为了将单个功能更形象的表现出来，如果要完全理解，还是要回到源码中看逻辑

代码注释

CountDownLatch 里面的代码

public class CountDownLatch {    //AbstractQueuedSynchronizer的具体类，真正控制线程的操作在这里实现    private static final class Sync extends AbstractQueuedSynchronizer {        private static final long serialVersionUID = 4982264981922014374L;        //构造方法，设置state,这里理解为设置计数器的大小        Sync(int count) {            setState(count);        }        //获取state,这里理解为获取计数器的大小        int getCount() {            return getState();        }        //尝试获取所，如果计数器的大小为0，返回1；                    //大小不为0，返回-1        protected int tryAcquireShared(int acquires) {            return (getState() == 0) ? 1 : -1;        }        //尝试释放锁        protected boolean tryReleaseShared(int releases) {            //开启自旋            // Decrement count; signal when transition to zero            for (;;) {                int c = getState();                if (c == 0)                    //如果锁已经全部释放了，返回false                    return false;                int nextc = c-1;                //通过CAS,更新计数器的大小                if (compareAndSetState(c, nextc))                    //释放一个锁（也就是计数器-1）以后，如果再也没有锁(计数器为0)，返回true,如果还有锁（计数器不为0），返回false                    return nextc == 0;            }        }    }    private final Sync sync;    //构造方法，计数器实际上是AbstractQueuedSynchronizer具体类的state    public CountDownLatch(int count) {        if (count < 0) throw new IllegalArgumentException("count < 0");        this.sync = new Sync(count);    }    //阻塞线程，等待计数器为0，    public void await() throws InterruptedException {        sync.acquireSharedInterruptibly(1);    }    //阻塞线程，等待计数器为0，或者超过给定的时间    public boolean await(long timeout, TimeUnit unit)        throws InterruptedException {        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));    }    //计数器的大小减去1    public void countDown() {        sync.releaseShared(1);    }    //获取计数器的大小    public long getCount() {        return sync.getCount();    }    //不解释    public String toString() {        return super.toString() + "[Count = " + sync.getCount() + "]";    }}

AbstractQueuedSynchronizer中有关await()中的部分代码

//await()中实际上是调用该方法public final void acquireSharedInterruptibly(int arg)        throws InterruptedException {    //处理异常    if (Thread.interrupted())        throw new InterruptedException();    //尝试获取锁，在这里，是调用CountDownLatch当中AbstractQueuedSynchronizer具体类中重写的方法    //计数器大小为0，返回1；否则为-1；    if (tryAcquireShared(arg) < 0)        //计数器大小不为0，执行该方法        doAcquireSharedInterruptibly(arg);}//计数器不为0时，调用该方法private void doAcquireSharedInterruptibly(int arg)    throws InterruptedException {    //向队列中添加一个节点，(如果当前队列没有head,先创建head,再添加node)    final Node node = addWaiter(Node.SHARED);    boolean failed = true;    try {        //开启自旋，如果计数器为0，会结束自旋        for (;;) {            //获取当前node的前一个node            final Node p = node.predecessor();            //判断当前node是不是第一个node            if (p == head) {                //如果是第一个node，查看计数器是否为0                int r = tryAcquireShared(arg);                if (r >= 0) {                    //计数器为0，说明所有的锁都释放了                    //将当前的node设置为head,也就是将队列中第一个node设置为head，同时也会唤醒挂起的线程                    setHeadAndPropagate(node, r);                    p.next = null; // help GC                    failed = false;                    //该方执行完毕，调用await()的线程可以继续执行                    return;                }            }            //将调用await()的线程挂起            if (shouldParkAfterFailedAcquire(p, node) &&                parkAndCheckInterrupt())                throw new InterruptedException();        }    } finally {        if (failed)            cancelAcquire(node);    }}

AbstractQueuedSynchronizer中有关countDown()中的部分代码

//countDown()实际上调用的是该方法public final boolean releaseShared(int arg) {    //尝试释放锁，在这里，是调用CountDownLatch当中AbstractQueuedSynchronizer具体类中重写的方法    //计数器-1，返回true,计数器大小没变，返回false    if (tryReleaseShared(arg)) {        //计数器大小-1，进入判断内部        doReleaseShared();        return true;    }    return false;}//计数器-1后，调用该方法private void doReleaseShared() {    //开启自旋    for (;;) {        Node h = head;        if (h != null && h != tail) {            int ws = h.waitStatus;            if (ws == Node.SIGNAL) {                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))                    //使用continue，是为了确保Status的状态一定会修改成功                    continue;            // loop to recheck cases                //唤醒挂起的线程，也就是doAcquireSharedInterruptibly（）当中的自旋执行一次，可能再次挂起或者结束                unparkSuccessor(h);            }            //唤醒线程后，head值改变的话，更新Status为PROPAGATE            else if (ws == 0 &&                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))                //确保Status一定会修改成功                continue;                // loop on failed CAS        }        //判读head是否更换（唤醒挂起的线程，有可能将head更新，也可能不更新）        if (h == head)                   // loop if head changed            //在这里，可以粗略的理解为：如果唤醒线程后，该线程仍然挂起，结束该方法的自旋            break;        //如果head改变，继续自旋，这样，就会调用compareAndSetWaitStatus(h, 0, Node.PROPAGATE)    }}

结语

上文中没有分析await(long timeout, TimeUnit unit)，留给各位Monkey去分析，顺便练习下看源码的能力。
看了这么多的分析，不要忘了CountDownLatch的作用：
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
简答说明：等待相应的线程结束后再去执行相关的代码。
源码作者：Doug Lea

转载请标明出处：http://blog.csdn.net/qq_26411333/article/details/51416373