1 介绍

  • countDownLatch：用于记录这些线程能执行的次数 并不是说一个线程只能执行一次。 完全可以在一个线程的run()方法里调两次甚至更多次latch.countDown() 让你的初始化值减为零。

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

    2 API说明

  • 构造器

    1. //参数count为计数值
    2. public CountDownLatch(int count) {  };

  • 类中有三个方法是最重要的：

    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() { };

    3 案例

    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. }

    4 结果

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

  • 原文链接：https://www.jianshu.com/p/e233bb37d2e6