CountDownLatch

这个类是一个帮助同步的工具类，一个或多个线程等待其它线程完成某些条件之后执行。

CountDownLatch在初始化时有一个变量count用于计数，当count==0时，等待线程将会被唤醒。这是一个一次性的工具，count不能被重置。

一个用例：

public class Main {
 
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        CountDownLatch start=new CountDownLatch(1);
        CountDownLatch end=new CountDownLatch(5);

        for (int i=0;i<5;i++){
            new Thread(new TastRunnable(start,end)).start();
        }
        System.out.println("main do something");
        start.countDown();
        System.out.println("main do else something");
        end.await();
        System.out.println("main 执行结束");
    }

    static class TastRunnable implements Runnable{
        private CountDownLatch startDown;
        private CountDownLatch endDown;

        public TastRunnable(CountDownLatch startDown, CountDownLatch endDown) {
            this.startDown = startDown;
            this.endDown = endDown;
        }

        @Override
        public void run() {
            try {
                startDown.await();

                System.out.println("任务开始执行了");

                endDown.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

---

await方法使用的是Sync锁，这是一个内部类，作用机制和reentrantLock基本一致。
只是这个sync在初始化的时候就把state赋值为1，也就是被占用的状态。

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

---

每次被调用countDown都会把sync的state-1,当state==0时，会唤醒所有在sync上等待的线程。

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