countDownLatch
1.背景：
- countDownLatch是在java1.5被引入，跟它一起被引入的工具类还有CyclicBarrier、Semaphore、concurrentHashMap和BlockingQueue。
- 存在于java.util.cucurrent包下。
2.概念
- countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。
- 是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。
3.源码
- countDownLatch类中只提供了一个构造器：
//参数count为计数值
public CountDownLatch(int count) { };
- 类中有三个方法是最重要的：
//调用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() { };
4.示例
普通示例：
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();
}
}
}
*CountDownLatch和CyclicBarrier区别： 1.countDownLatch是一个计数器，线程完成一个记录一个，计数器递减，只能只用一次 2.CyclicBarrier的计数器更像一个阀门，需要所有线程都到达，然后继续执行，计数器递增，提供reset功能，可以多次使用
关于CyclicBarrier的使用介绍前言：假如周末聚会，先到的人要等待还没有达到的人，要等到人到齐了之后才能开始吃饭，那么对于这种场景，用代码如何表示呢…
1.CyclicBarrier什么鬼 从字面上来看，Cyclic（可循环使用）Barrier（屏障）。它的功能是让一组线程达到一个屏障或者公共点时被阻塞，直到最后一个线程也到达屏障时，才会打开屏障，所有被屏障拦截的线程才会继续运行。 CyclicBarrier默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。 下面是官方介绍
CyclicBarrier是一个同步辅助类，它允许一组线程相互等待，直到到达某个公共屏障点。在涉及一组固定大小的线程的程序中，这些线程必须相互等待，此时CyclicBarrier很有用。因为该barrier在释放等待线程后可以重复使用，所以称它为循环的barrier。
2.CyclicBarrier的简单使用
public class CyclicBarrierTest {
public static void main(String[] args) {
ExecutorService executor = Executors.newCachedThreadPool();
//周末3人聚会，需要等待3个人全部到齐餐厅后才能开始吃饭
CyclicBarrier cb = new CyclicBarrier(3);
System.out.println("初始化：有" + (3 - cb.getNumberWaiting()) + "个人正在赶来餐厅");
for (int i = 0; i < 3; i++) { //定义3个任务，即3个人从家里赶到餐厅
//设置用户的编号
final int person = i;
executor.execute(() -> { //lambda表达式
try {
//此处睡眠，模拟3个人从家里来到餐厅所花费的时间
Thread.sleep((long) (Math.random() * 10000));
System.out.println(Thread.currentThread().getName() + "---用户" + person + "即将达到餐厅," +
"用户" + person + "到达餐厅了。" + "当前已有" + (cb.getNumberWaiting() + 1) + "个人到达餐厅");
cb.await();
System.out.println("三个人都到到餐厅啦，" + Thread.currentThread().getName() + "开始吃饭了");
//todo 吃完饭后想去网吧开黑 这里具体代码我就不写啦 留给小伙伴自己实现 >.<
//再次wait(),等待3个人全部到达网吧 cb是可以复用的！
cb.await();
//3个人都到达网吧了，开始玩游戏 playGame()...
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
});
}
executor.shutdown(); //关闭线程池
}
}
运行结果如下：
初始化：有3个人正在赶来餐厅
pool-1-thread-3---用户2即将达到餐厅,用户2到达餐厅了。当前已有1个人到达餐厅
pool-1-thread-2---用户1即将达到餐厅,用户1到达餐厅了。当前已有2个人到达餐厅
pool-1-thread-1---用户0即将达到餐厅,用户0到达餐厅了。当前已有3个人到达餐厅
三个人都到到餐厅啦，pool-1-thread-3开始吃饭了
三个人都到到餐厅啦，pool-1-thread-2开始吃饭了
三个人都到到餐厅啦，pool-1-thread-1开始吃饭了
可以发现，当3个人全部达到餐厅之后，才会开始吃饭，其中开始吃饭是同时打印的。
另外，CyclicBarrier还提供一个更高级的构造函数CyclicBarrier(int parties, Runnable barrierAction)，用于在线程到达屏障时，优先执行barrierAction。 这里就不再展开介绍了，和上面的大同小异，只不过在构建CyclicBarrier的时候，创建一个优先执行的动作。
