Java并发学习(十七)-并发工具CountDownLatch

另一个并发工具，CountDownLatch，和CyclicBarrier功能上有点类似，但是在实现上和是不同的。

What is CountDownLatch

简单的说，也是一个计数器，和CyclicBarrier相比，一定方面是更加灵活的，CountDownLatch可以在任意代码处通知自己已完成，等所有都做完时，主线程就可以接下来运行了。有需要可参看：Java并发学习(十六)-并发工具CyclicBarrier 。

结构

CountDownLatch里面维护这一个AbstractQueuedSynchronizer的子类，其实就是基于AQS的共享锁的应用。
看看Sync的代码：

    private static final class Sync extends AbstractQueuedSynchronizer {        //count去初始化state。        Sync(int count) {            setState(count);        }        //获取state。        int getCount() {            return getState();        }        //重写父类方法，获取共享锁。        protected int tryAcquireShared(int acquires) {            return (getState() == 0) ? 1 : -1;        }        /**         * 释放锁。         * 自减state。         */        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))                    return nextc == 0;            }        }    }

上述代码只是简单的对AQS的state变量的CAS原子操作。
下面通过主要方法await和countDown来分析里面的实现逻辑。

await

一般我们用关于锁的方法时，都是lock和unlock，但是这里是await，你可以理解为，当所有线程执行完后，再需要执行的线程a，那么这个a就可以先await，等到其他的执行完，a就可以执行了。
首先执行await：

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

再看父类的acquireSharedInterruptibly方法：

    public final void acquireSharedInterruptibly(int arg)            throws InterruptedException {        if (Thread.interrupted())            throw new InterruptedException();            //<0，代表没有获取到锁，所以需要自旋方式再次尝试，            //结果可能被park挂起，或者获取到锁        if (tryAcquireShared(arg) < 0)            doAcquireSharedInterruptibly(arg);    }

我们再看看子类重写的tryAcquireShared方法：

//重写父类方法，获取共享锁。        protected int tryAcquireShared(int acquires) {            return (getState() == 0) ? 1 : -1;        }

当state为0时候，结果为1，放到acquireSharedInterruptibly 里面就是获取到锁;
而当state不为0，则结果为-1，也就是代表没有获取到锁。

而最开始CountDownLatch的构造方法：

public CountDownLatch(int count) {        if (count < 0) throw new IllegalArgumentException("count < 0");        this.sync = new Sync(count);    }

所以count会传入大于0的，代表等待着count个线程。

现在就明了了，调用这个方法是用来阻塞的。

countDown

countDown什么时候用呢？
上面说过，其他的众多运行线程，countDown方法就是其他众多运行线程用，当你的工作线程运行完后，旧值性countDown方法。

    public void countDown() {        sync.releaseShared(1);    }

再看父类的releaseShared方法：

    public final boolean releaseShared(int arg) {        if (tryReleaseShared(arg)) {            doReleaseShared();            return true;        }        return false;    }

tryReleaseShared方法在上面Sync里面，主要就是对count值自减，而doReleaseShared则是unpark唤醒后继符合条件线程。

具体使用例子

从Java doc里面可以看到两个典型例子，这里以例说明。

任务分割情况：

 class Driver2 {    void main() throws InterruptedException {     CountDownLatch doneSignal = new CountDownLatch(N);     //线程池执行     Executor e = ...     for (int i = 0; i < N; ++i) // create and start threads       e.execute(new WorkerRunnable(doneSignal, i));    //等待，主线程main的await后面代码挂起等待     doneSignal.await();     //这后面方法，必须等所有其他的都countDown一次，才会被唤醒执行。               afterawait();   } } class WorkerRunnable implements Runnable {   private final CountDownLatch doneSignal;   private final int i;   WorkerRunnable(CountDownLatch doneSignal, int i) {     this.doneSignal = doneSignal;     this.i = i;   }   public void run() {     try {       doWork(i);       //我做完了，我利用countDown通知下，但是不阻塞当前线程       doneSignal.countDown();     } catch (InterruptedException ex) {} // return;   }    //具体工作方法   void doWork() { ... } }

任务分割情况，就是把让其他众多线程a1,a2,a3…..全部运行完后，主线程b才能够执行。注意需要共用这一个CountDownLatch。

多控制计数器：

下面是一对类，其中一组工作线程使用两个倒计时锁存器：

• 首先是一个启动信号，防止任何工人进行，直到司机准备好进行;
• 第二个是完成信号，允许驾驶员等待所有工人完成。

 class Driver { // ...   void main() throws InterruptedException {   //定义两个CountDownLatch     CountDownLatch startSignal = new CountDownLatch(1);     CountDownLatch doneSignal = new CountDownLatch(N);    //运行一组线程     for (int i = 0; i < N; ++i)        new Thread(new Worker(startSignal, doneSignal)).start();    //做些事     doSomethingElse();                 //做完后，调用startSiganl的countDown     startSignal.countDown();           //做另外一件事     doSomethingElse();     //等待doneSignal的信号     doneSignal.await();             } } class Worker implements Runnable {   private final CountDownLatch startSignal;   private final CountDownLatch doneSignal;   Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {     this.startSignal = startSignal;     this.doneSignal = doneSignal;   }   public void run() {     try {     //首先等待startSignal的信号       startSignal.await();       //等到信号了，做事       doWork();       //对doneSignal发出信号，说做好了       doneSignal.countDown();     } catch (InterruptedException ex) {} // return;   }   void doWork() { ... } }

与CyclicBarrier对比

从功能和实现上，CountDownLatch还是有点区别的：

• CyclicBarrier内部是使用ReentrantLock和Condition来实现等待和唤醒操作，而CountDownLatch则是直接利用AQS，采用共享锁来实现。
• CyclicBarrier可以重利用，而CountDownLatch则只能使用一次。
• CountDownLatch的作用是允许1或N个线程await等待其他线程完成（countDown）执行；而CyclicBarrier则是允许N个线程相互等待，即等到最后一个进入的去唤醒所有等待的。

与join对比

在Thread里面，还有个join方法，用于即阻塞当前线程直到执行join的线程运行完：

public class JoinCountDownLatchTest {    public static void main(String[] args) throws InterruptedException {        Thread thread1 = new Thread(new Runnable() {            public void run() {                System.out.println("parser1 finish");            }        });        Thread thread2 = new Thread(new Runnable() {            public void run() {                System.out.println("parser2 finish");            }        });        thread1.start();        thread2.start();        thread1.join();        thread2.join();        System.out.println("all parser finish");    }}

运行结果：

所以对与join也有等待线程的功能，但是来看join的代码实现：

    public final synchronized void join(long millis)    throws InterruptedException {        long base = System.currentTimeMillis();        long now = 0;        //判断等待时间        if (millis < 0) {            throw new IllegalArgumentException("timeout value is negative");        }        //默认等待时间        if (millis == 0) {        //如果当前线程仍然存活，那么就一直等待            while (isAlive()) {                wait(0);            }        } else {            while (isAlive()) {                long delay = millis - now;                if (delay <= 0) {                    break;                }                wait(delay);                now = System.currentTimeMillis() - base;            }        }    }

最后，直到join线程中止后，线程的this.notifyAll会被调用。所以main线程最后会被唤醒，当然，join方法里面使用了传统的synchronized关键字，以及wait，notify，notifyAll等方法，JDK不推荐在线程实例上使用wait，notify和notifyAll方法。

参考资料：
1. https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CountDownLatch.html
2. http://ifeve.com/talk-concurrency-countdownlatch/