基于信号量的线程阻塞工具。 用在某个线程等待其他线程执行完毕，再继续执行。

    CountDownLatch 初始设定信号量
    countDown() 任何线程都可以调用 countDown() 将信号量减一 （本线程也可调用，单线程内可调用多次）
    await()方法，阻塞一个到多个线程。

    当信号量归0，阻塞释放。

    阻塞的过程是通过AQS实现的， 使用自旋锁循环监控阻塞状态。

    1. public class CountLatchTest {
    3.     public static void main(String[] args) throws InterruptedException {
    5.         CountDownLatch countDownLatch = new CountDownLatch(5);
    7.         for (int i = 0; i <5 ; i++) {
    8.             new Thread(()->{
    9.                 System.out.println("开始执行"+Thread.currentThread());
    10.                 try {
    11.                     Thread.sleep(1000 + Math.round( Math.random()*1000));
    12.                 } catch (InterruptedException e) {}
    13.                 countDownLatch.countDown();
    14.                 System.out.println("执行结束"+Thread.currentThread());
    15.             }).start();
    16.         }
    18.         countDownLatch.await();
    20.         System.out.println("主线程执行完成");
    21.     }
    22. }

    以下实例，阻塞多个线程，使得多个线程阻塞在某一步，信号量归0，继续一起执行。

    如以上，多个线程都开始后，打出了开始输出，再继续往下执行。

    1. public class CountLatchTest {
    3.     public static void main(String[] args) throws InterruptedException {
    4.         CountDownLatch countDownLatch = new CountDownLatch(5);
    6.         for (int i = 0; i <5 ; i++) {
    7.             new Thread(()->{
    8.                 try {
    9.                     System.out.println("开始执行"+Thread.currentThread());
    10.                     countDownLatch.countDown();
    11.                     //阻塞
    12.                     countDownLatch.await();
    13.                     System.out.println("执行结束"+Thread.currentThread());
    14.                 } catch (InterruptedException e) {
    15.                     e.printStackTrace();
    16.                 }
    17.             }).start();
    18.         }
    20.         //阻塞
    21.         countDownLatch.await();
    22.         System.out.println("主线程执行完成");
    23.     }
    24. }