背景
CountDownLatch 是在 JDK1.5 的时候才被引入，跟它一起被引入的工具类还有 CyclicBarrier（回环栅栏）、Semaphore（信号量）、ConcurrentHashMap（并发 Hash 表）和 BlockingQueue（阻塞队列），存在于 java.util.concurrent 包下（常说 JUC）。接下来讲解一下这个同步神器 CountDownLatch（倒计时计算器）。
概念
CountDownLatch 是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（属于共享机制而不是用作互斥的作用）。
CountDownLatch 能够使一个或多个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为可以定制化设置倒计时数值。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为 0 时，表示所有的线程都已经完成一些任务，然后被 CountDownLatch 上阻塞而等待的线程就可以被触发，从阻塞状态恢复可执行状态执行接下来的任务。
CountDownLatch 的用法
场景一
某一线程在开始运行前等待 n 个线程执行完毕。
将 CountDownLatch 的计数器初始化为 new CountDownLatch(n)
希望等待的线程上执行 CountDownLatch 上 await()操作，使得当前线程会被阻塞（底层 LockSupport 阻塞）任何线程都会被阻塞，即使是 main 线程。
将 CountDownLatch 对象传入到每个执行结果作为触发条件的线程中去，每当一个任务线程执行完毕，就将计数器减 1，countdownLatch.countDown()。
当计数器的值变为 0 时，被阻塞的线程就会被唤醒，继续执行接下来要执行的操作机制。
一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。
场景二
实现多个线程开始执行任务的最大并行性。
注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。
类似于赛跑将多个线程放到起点，等待发令枪响，然后同时开跑。
做法是初始化一个共享的 CountDownLatch(1)，将其计算器初始化为 1，
多个线程在开始执行任务前首先 countdownlatch.await()，
当主线程调用 countDown()时，计数器变为 0，多个线程同时被唤醒。
CountDownLatch 的不足
CountDownLatch 是一次性的，计算器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当 CountDownLatch 使用完毕后，它不能再次被使用，相对的 CyclicBarrier 解决了这个问题。
CountDownLatch 使用说明
构造器
//参数count为计数值public CountDownLatch(int count) { };
复制代码
计数器倒计时方法
//递减锁存器的计数，如果计数到达零，则释放所有等待的线程。如果当前计数大于零，则将计数减少.public void countDown()
复制代码
调用 countDown()，计数到达零；或者其他某个线程中断当前线程；或者已超出指定的等待时间。
线程阻塞等待方法
//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行public void await() throws InterruptedException { };
复制代码
//使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间，//如果当前计数为零，则此方法立刻返回true值，如果当前计数大于零，则出于线程调度目的，将阻塞当前线程public boolean await(long timeout,TimeUnit unit) throws InterruptedException
复制代码
发生以下几种情况之前，该线程将一直出于休眠状态：
如果计数到达零，则该方法返回 true 值。
如果当前线程，进入此方法时已经设置了该线程的中断状态；
在等待时被中断，则抛出 InterruptedException，并且清除当前线程的已中断状态。
如果超出了指定的等待时间，则返回值为 false。如果该时间小于等于零，则该方法根本不会等待。
参数：
timeout-要等待的最长时间
unit-timeout 参数的时间单位
返回：
如果计数到达零，则返回 true；
如果在计数到达零之前超过了等待时间，则返回 false
抛出：
InterruptedException-如果当前线程在等待时被中断
实际案例
主线程等待子线程执行
package com.example.demo.CountDownLatchDemo;
import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;
/** * 主线程等待子线程执行完成再执行 */public class CountdownLatchTest1 { public static void main(String[] args) { ExecutorService service = Executors.newFixedThreadPool(3); final CountDownLatch latch = new CountDownLatch(3); for (int i = 0; i < 3; i++) { Runnable runnable = new Runnable() { @Override public void run() { try { System.out.println("子线程" + Thread.currentThread().getName() + "开始执行"); Thread.sleep((long) (Math.random() * 10000)); System.out.println("子线程"+Thread.currentThread().getName()+"执行完成"); latch.countDown();//当前线程调用此方法，则计数减一 } catch (InterruptedException e) { e.printStackTrace(); } } }; service.execute(runnable); } try { System.out.println("主线程"+Thread.currentThread().getName()+"等待子线程执行完成..."); latch.await();//阻塞当前线程，直到计数器的值为0 System.out.println("主线程"+Thread.currentThread().getName()+"开始执行..."); } catch (InterruptedException e) { e.printStackTrace(); } }}
复制代码
赛跑机制
package com.example.demo.CountDownLatchDemo;
import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;
public class CountdownLatchTest2 { public static void main(String[] args) { ExecutorService service = Executors.newCachedThreadPool(); final CountDownLatch cdOrder = new CountDownLatch(1); final CountDownLatch cdAnswer = new CountDownLatch(4); for (int i = 0; i < 4; i++) { Runnable runnable = new Runnable() { @Override public void run() { try { System.out.println("选手" + Thread.currentThread().getName() + "正在等待裁判发布口令"); cdOrder.await(); System.out.println("选手" + Thread.currentThread().getName() + "已接受裁判口令"); Thread.sleep((long) (Math.random() * 10000)); System.out.println("选手" + Thread.currentThread().getName() + "到达终点"); cdAnswer.countDown(); } catch (InterruptedException e) { e.printStackTrace(); } } }; service.execute(runnable); } try { Thread.sleep((long) (Math.random() * 10000)); System.out.println("裁判"+Thread.currentThread().getName()+"即将发布口令"); cdOrder.countDown(); System.out.println("裁判"+Thread.currentThread().getName()+"已发送口令，正在等待所有选手到达终点"); cdAnswer.await(); System.out.println("所有选手都到达终点"); System.out.println("裁判"+Thread.currentThread().getName()+"汇总成绩排名"); } catch (InterruptedException e) { e.printStackTrace(); } service.shutdown(); }}
复制代码
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(); } }}
复制代码
评论