CountDownLatch

1、概念

  CountDownLatch:具有计数器的功能，等待其他线程执行完毕，主线程在继续执行，用于监听某些初始化操作，并且线程进行阻塞，等初始化执行完毕后，通知主线程继续工作执行

       CountDownLatch计数的次数一定要与构造器传入的数字一致，比如构造器传入的是3，则countDown()一定要执行3次，否则线程将一直阻塞。CountDownLatch通常用来控制线程等待，它可以让线程等待倒计时结束，再开始执行。

      CountDownLatch 一个同步辅助类，以计数的方式在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

2 CountDownLatch的用法

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

使用

1某一线程在开始运行前等待n个线程执行完毕。

2 实现多个线程开始执行任务的最大并行性

 

3CountDownLatch的不足

CountDownLatch是一次性的，计算器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。

 

4区别

  CountDownLatch: 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。
  CyclicBrrier: N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。

 

实列：不用CountDownLatch结果

public class myCountDownLatchTest {

    public static void main(String[] args) throws InterruptedException
    {
          new Thread(new Runnable(){
              @Override
              public void run() {
                  System.out.println("线程1开始"+Thread.currentThread().getName());
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  System.out.println("开始1结束"+Thread.currentThread().getName());
              }
          }

          ).start();
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("线程2开始"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("开始2结束"+Thread.currentThread().getName());
             
            }
        }

        ).start();

         

        System.out.println("结束");

    }
}
结果：

结束
线程1开始Thread-0
线程2开始Thread-1
开始2结束Thread-1
开始1结束Thread-0

 

实列：加入CountDownLatch结果

import java.util.concurrent.CountDownLatch;

public class myCountDownLatchTest {

    public static void main(String[] args) throws InterruptedException
    {
        CountDownLatch countDownLatch=new CountDownLatch(2);
          new Thread(new Runnable(){


              @Override
              public void run() {
                  System.out.println("线程1开始"+Thread.currentThread().getName());
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  System.out.println("开始1结束"+Thread.currentThread().getName());
                  countDownLatch.countDown();
              }
          }

          ).start();
        new Thread(new Runnable(){


            @Override
            public void run() {
                System.out.println("线程2开始"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("开始2结束"+Thread.currentThread().getName());
                countDownLatch.countDown();
            }
        }

        ).start();

          countDownLatch.await();

        System.out.println("结束");

    }
}

结果：（发现等线程执行完成后 才去 打印出 结束）

线程1开始Thread-0
线程2开始Thread-1
开始1结束Thread-0
开始2结束Thread-1
结束