CountDownLatch
CountDownLatch是一个多线程控制工具类，这个工具类用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。
（1）CountDownLatch的构造函数
public CountDownLatch(int count)
CountDownLatch的构造函数接收一个整数作为参数，即为当前这个计数器的计数个数。
（2）CountDownLatch类中的方法
1）public void await() throws InterruptedException{};
调用await方法的线程会被挂起，直至count值为0后才会继续执行。
2）public void countdown();
count值减1。
3）public void await(long timeout,TimeUnit unit) throws InterruptedException{};
与await方法类似，只是在等待一定的时间之后，count值还没有变为0，会继续执行。
package com.example.demo.test;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CountDownLatchDemo implements Runnable{
static final CountDownLatch countDownLatch = new CountDownLatch(10);
static final CountDownLatchDemo countDownLatchDemo = new CountDownLatchDemo();
@Override
public void run() {
try {
Thread.sleep(3000);
System.out.println("检查是否完成！");
countDownLatch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i=0;i<10;i++){
executorService.submit(countDownLatchDemo);
}
countDownLatch.await();
System.out.println("开始！");
executorService.shutdown();
}
}
CyclicBarrier
CyclicBarrier也是一种多线程并发控制实用工具，也可以实现线程间的计数等待。
package com.example.demo.test;
import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
public static void main(String[] args) {
final int N = 10;
Thread [] allSoldier = new Thread[N];
boolean flag = false;
CyclicBarrier cyclicBarrier = new CyclicBarrier(N,new BarrierRun(false,N));
System.out.println("队伍集合！");
for(int i=0;i<N;i++){
System.out.println("士兵"+i+"报道！");
allSoldier[i] = new Thread(new Soldier(cyclicBarrier,"士兵"+i));
allSoldier[i].start();
}
}
public static class Soldier implements Runnable{
private String soldier;
private final CyclicBarrier cyclicBarrier;
public Soldier(CyclicBarrier cyclicBarrier,String soldier){
this.soldier = soldier;
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
try {
cyclicBarrier.await();
doWork();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
public void doWork(){
try {
Thread.sleep(Math.abs(new Random().nextInt()%10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(soldier+"：任务完成");
}
}
public static class BarrierRun implements Runnable{
boolean flag;
int N;
public BarrierRun(boolean flag, int N){
this.flag = flag;
this.N = N;
}
@Override
public void run() {
if(flag){
System.out.println("司令：【士兵"+N+"个，任务完成！】");
}else{
System.out.println("司令：【士兵"+N+"个，集合完毕！】");
flag = true;
}
}
}
}
