CountDownLatch

这个类使一个线程等待其他线程各自执行完毕后再执行。

是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。

API

  1. //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
  2. public void await() throws InterruptedException { };   
  3. //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
  4. public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
  5. //将count值减1
  6. public void countDown() { };

使用示例: 

  1. public class CountDownLatchTest {
  3.     public static void main(String[] args) {
  4.         final CountDownLatch latch = new CountDownLatch(2);
  5.         System.out.println("主线程开始执行…… ……");
  6.         //第一个子线程执行
  7.         ExecutorService es1 = Executors.newSingleThreadExecutor();
  8.         es1.execute(new Runnable() {
  9.             @Override
  10.             public void run() {
  11.                 try {
  12.                     Thread.sleep(3000);
  13.                     System.out.println("子线程："+Thread.currentThread().getName()+"执行");
  14.                 } catch (InterruptedException e) {
  15.                     e.printStackTrace();
  16.                 }
  17.                 latch.countDown();
  18.             }
  19.         });
  20.         es1.shutdown();
  22.         //第二个子线程执行
  23.         ExecutorService es2 = Executors.newSingleThreadExecutor();
  24.         es2.execute(new Runnable() {
  25.             @Override
  26.             public void run() {
  27.                 try {
  28.                     Thread.sleep(3000);
  29.                 } catch (InterruptedException e) {
  30.                     e.printStackTrace();
  31.                 }
  32.                 System.out.println("子线程："+Thread.currentThread().getName()+"执行");
  33.                 latch.countDown();
  34.             }
  35.         });
  36.         es2.shutdown();
  37.         System.out.println("等待两个线程执行完毕…… ……");
  38.         try {
  39.             latch.await();
  40.         } catch (InterruptedException e) {
  41.             e.printStackTrace();
  42.         }
  43.         System.out.println("两个子线程都执行完毕，继续执行主线程");
  44.     }
  45. }
  1. 主线程开始执行…… ……
  2. 等待两个线程执行完毕…… ……
  3. 子线程：pool-1-thread-1执行
  4. 子线程：pool-2-thread-1执行
  5. 两个子线程都执行完毕，继续执行主线程
  1. public class Parallellimit {
  2.     public static void main(String[] args) {
  3.         ExecutorService pool = Executors.newCachedThreadPool();
  4.         CountDownLatch cdl = new CountDownLatch(100);
  5.         for (int i = 0; i < 100; i++) {
  6.             CountRunnable runnable = new CountRunnable(cdl);
  7.             pool.execute(runnable);
  8.         }
  9.     }
  10. }
  12.  class CountRunnable implements Runnable {
  13.     private CountDownLatch countDownLatch;
  14.     public CountRunnable(CountDownLatch countDownLatch) {
  15.         this.countDownLatch = countDownLatch;
  16.     }
  17.     @Override
  18.     public void run() {
  19.         try {
  20.             synchronized (countDownLatch) {
  21.                 /*** 每次减少一个容量*/
  22.                 countDownLatch.countDown();
  23.                 System.out.println("thread counts = " + (countDownLatch.getCount()));
  24.             }
  25.             countDownLatch.await();
  26.             System.out.println("concurrency counts = " + (100 - countDownLatch.getCount()));
  27.         } catch (InterruptedException e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31. }

调用countDownLatch对象的await()方法后,当前线程会被阻塞,直到下面的情况之一发生时:

  1. 当所有线程都调用CountDownLatch对象的countDown()后,计数器为0时
  2. 其他线程调用了当前线程的interrupt()方法,中断当前线程,当前线程会抛出InterruptedException异常,然后返回

    实现原理

    先前介绍过如何基于AQS同步器实现一个自定义同步器，实际上CountdownLatch也是基于AQS来实现的，只要使用AQS的共享模式即可以轻松实现闭锁。

CountdownLatch类的构造函数需要传入一个整型参数，表示倒计数器的初始值，对应着AQS的state状态变量。按照官方推荐的自定义同步器的做法，将继承了AQS类的子类Sync作为CountdownLatch类的内部类，而CountdownLatch同步器中相关的操作只需代理成子类中对应的方法即可。比如await方法和countDown方法分别调用Sync子类的acquireSharedInterruptibly方法和releaseShared方法。image.png
Sync子类中需要我们实现的两个方法是tryAcquireShared和tryReleaseShared，分别用于获取共享锁和释放共享锁。先看获取共享锁的逻辑，如果状态变量等于0则返回1，当倒计数器的值减少到0的时候全部线程都可以直接尝试得到共享锁，而当倒计数器的值为非0时使之返回-1交给AQS进行入队管理。然后看释放共享锁的逻辑，主要是通过自旋来进行减一操作，getState方法获取状态变量，将其值减一后使用compareAndSetState方法进行CAS修改状态值。

CountDownLatch和CyclicBarrier区别

1.countDownLatch是一个计数器，线程完成一个记录一个，计数器递减，只能只用一次
2.CyclicBarrier的计数器更像一个阀门，需要所有线程都到达，然后继续执行，计数器递增，提供reset功能，可以多次使用

参考文章:
作者：指尖架构141319 链接：https://www.jianshu.com/p/e233bb37d2e6

  1. //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
  2. public void await() throws InterruptedException { };   
  3. //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
  4. public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
  5. //将count值减1
  6. public void countDown() { };
  1. public class CountDownLatchTest {
  3.     public static void main(String[] args) {
  4.         final CountDownLatch latch = new CountDownLatch(2);
  5.         System.out.println("主线程开始执行…… ……");
  6.         //第一个子线程执行
  7.         ExecutorService es1 = Executors.newSingleThreadExecutor();
  8.         es1.execute(new Runnable() {
  9.             @Override
  10.             public void run() {
  11.                 try {
  12.                     Thread.sleep(3000);
  13.                     System.out.println("子线程："+Thread.currentThread().getName()+"执行");
  14.                 } catch (InterruptedException e) {
  15.                     e.printStackTrace();
  16.                 }
  17.                 latch.countDown();
  18.             }
  19.         });
  20.         es1.shutdown();
  22.         //第二个子线程执行
  23.         ExecutorService es2 = Executors.newSingleThreadExecutor();
  24.         es2.execute(new Runnable() {
  25.             @Override
  26.             public void run() {
  27.                 try {
  28.                     Thread.sleep(3000);
  29.                 } catch (InterruptedException e) {
  30.                     e.printStackTrace();
  31.                 }
  32.                 System.out.println("子线程："+Thread.currentThread().getName()+"执行");
  33.                 latch.countDown();
  34.             }
  35.         });
  36.         es2.shutdown();
  37.         System.out.println("等待两个线程执行完毕…… ……");
  38.         try {
  39.             latch.await();
  40.         } catch (InterruptedException e) {
  41.             e.printStackTrace();
  42.         }
  43.         System.out.println("两个子线程都执行完毕，继续执行主线程");
  44.     }
  45. }
主线程开始执行…… ……
等待两个线程执行完毕…… ……
子线程：pool-1-thread-1执行
子线程：pool-2-thread-1执行
两个子线程都执行完毕，继续执行主线程

public class Parallellimit {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        CountDownLatch cdl = new CountDownLatch(100);
        for (int i = 0; i < 100; i++) {
            CountRunnable runnable = new CountRunnable(cdl);
            pool.execute(runnable);
        }
    }
}

 class CountRunnable implements Runnable {
    private CountDownLatch countDownLatch;
    public CountRunnable(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        try {
            synchronized (countDownLatch) {
                /*** 每次减少一个容量*/
                countDownLatch.countDown();
                System.out.println("thread counts = " + (countDownLatch.getCount()));
            }
            countDownLatch.await();
            System.out.println("concurrency counts = " + (100 - countDownLatch.getCount()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await() throws InterruptedException { };   
//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
//将count值减1
public void countDown() { };

public class CountDownLatchTest {

    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(2);
        System.out.println("主线程开始执行…… ……");
        //第一个子线程执行
        ExecutorService es1 = Executors.newSingleThreadExecutor();
        es1.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                    System.out.println("子线程："+Thread.currentThread().getName()+"执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                latch.countDown();
            }
        });
        es1.shutdown();

        //第二个子线程执行
        ExecutorService es2 = Executors.newSingleThreadExecutor();
        es2.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("子线程："+Thread.currentThread().getName()+"执行");
                latch.countDown();
            }
        });
        es2.shutdown();
        System.out.println("等待两个线程执行完毕…… ……");
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("两个子线程都执行完毕，继续执行主线程");
    }
}

主线程开始执行…… ……
等待两个线程执行完毕…… ……
子线程：pool-1-thread-1执行
子线程：pool-2-thread-1执行
两个子线程都执行完毕，继续执行主线程

public class Parallellimit {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        CountDownLatch cdl = new CountDownLatch(100);
        for (int i = 0; i < 100; i++) {
            CountRunnable runnable = new CountRunnable(cdl);
            pool.execute(runnable);
        }
    }
}

 class CountRunnable implements Runnable {
    private CountDownLatch countDownLatch;
    public CountRunnable(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        try {
            synchronized (countDownLatch) {
                /*** 每次减少一个容量*/
                countDownLatch.countDown();
                System.out.println("thread counts = " + (countDownLatch.getCount()));
            }
            countDownLatch.await();
            System.out.println("concurrency counts = " + (100 - countDownLatch.getCount()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}