1. CountDownLatch 类
CountDownLatch 类是用于线程同步的工具，作用：让一个或多个源线程（调用await方法的线程） 必须 等待一个或多个目标线程（调用countDown方法的线程）都执行完成了才能继续执行自己的代码。
注意：
1. 不会妨碍目标线程的执行，但是会阻塞源线程，因为await方法会检测count是为0，如果不是0，就会阻塞，不会继续执行后面的代码。
2. 它是一次性的，不能重复用，因为count变为0之后，就不会再改变了，只有一个countDown方法去减，没有方法去让count加，所以如果你重复使用的话，不起作用，count永远为0。
3. 当然，你可以在一个线程的run方法里调用多次countDown 方法，多减几个1。
比如一个测评系统，需要测评一个人的优秀值good，good是通过一个计算公式来计算出的，这个公式为good = 身高 + 体重 + 智力 + 情商 + 颜值，那么我们可以创建5个线程A，B，C，D，E，分别去测试出：身高、体重、智力、情商、颜值，要想计算出good，必须等待5个线程都执行完毕，身高、体重、智力、情商、颜值都得到了，才能进一步计算good。 此时CountDownLatch类就有用了。
public class CountDownLatch {
// 构造方法，初始化计数值
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
//判断count是否为0，为0才能继续执行下去，否则就一直阻塞
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
//判断count是否为0，为0才能继续执行下去，否则就一直阻塞，如果阻塞时间超过了unit，就继续执行
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
//让count减1
public void countDown() {
sync.releaseShared(1);
}
//获取count的值
public long getCount() {
return sync.getCount();
}
}
举个例子：
其实这个例子里面不应该将CountDownLatch对象定为静态的（定义为普通的就行），因为不能重复使用，定义为静态的干嘛。
public class Main {
public static CountDownLatch countDownLatch = new CountDownLatch(2);
public static void main(String[] args) throws InterruptedException {
MyThread myThread = new MyThread();
myThread.start();
MyThread myThread1 = new MyThread();
myThread1.start();
countDownLatch.await();
System.out.println("彻底结束啦");
}
}
public class MyThread extends Thread {
@Override
public void run() {
super.run();
System.out.println("当前线程是：" + Thread.currentThread().getName());
Main.countDownLatch.countDown();
System.out.println("结束");
}
}
2. CyclicBarrier类
CyclicBarrier 类也是线程同步工具类，CountDownLatch类能做到的，它都能做到，而且功能更多，作用：仅仅让多个线程同时开始执行。 形象地比喻为栅栏，所有达到栅栏的线程都得停下，只能线程数量达到了规定的数量后，才打开栅栏，让所有线程同时继续运行。
注意：
1. 它不会阻塞源线程，但是它阻塞目标线程。
2. 能够重复使用，就好像count减为0之后，我们能够调用reset方法将count再次重置为初始值。
3. 不用特意调用reset方法去达到循环使用，比如parties是3，直接启动3个线程后，接着直接启动别的线程就行。
public class CyclicBarrier {
//用于记录同一批线程属于一代
private static class Generation {
boolean broken = false;
}
//入口锁，就是要达到栅栏，也得一个一个来吧，不能两个线程同时进行吧，因此要一个锁
private final ReentrantLock lock = new ReentrantLock();
//条件锁，当线程到达栅栏时，锁住它，不让其执行，等线程数量满足条件后，锁打开，线程继续执行
private final Condition trip = lock.newCondition();
// 记录栅栏开启所需的线程数，以便重置的时候使用
private final int parties;
//线程数量达到要求后，执行的内容
private final Runnable barrierCommand;
private Generation generation = new Generation();
//count类似于CountDownLatch中的count
private int count;
//进入下一代了，上一批线程已经处理完了，可以接受下一批了
private void nextGeneration() {
trip.signalAll();
count = parties;
generation = new Generation();
}
//终止栅栏
private void breakBarrier() {
generation.broken = true;
count = parties;
trip.signalAll();
}
//await就是通过dowait实现的
private int dowait(boolean timed, long nanos)
throws InterruptedException, BrokenBarrierException,
TimeoutException {
final ReentrantLock lock = this.lock;
lock.lock();
try {
final Generation g = generation;
if (g.broken)
throw new BrokenBarrierException();
if (Thread.interrupted()) {
breakBarrier();
throw new InterruptedException();
}
int index = --count;
if (index == 0) { // tripped
boolean ranAction = false;
try {
final Runnable command = barrierCommand;
if (command != null)
command.run();
ranAction = true;
nextGeneration();
return 0;
} finally {
if (!ranAction)
breakBarrier();
}
}
// loop until tripped, broken, interrupted, or timed out
for (;;) {
try {
if (!timed)
trip.await();
else if (nanos > 0L)
nanos = trip.awaitNanos(nanos);
} catch (InterruptedException ie) {
if (g == generation && ! g.broken) {
breakBarrier();
throw ie;
} else {
// We're about to finish waiting even if we had not
// been interrupted, so this interrupt is deemed to
// "belong" to subsequent execution.
Thread.currentThread().interrupt();
}
}
if (g.broken)
throw new BrokenBarrierException();
if (g != generation)
return index;
if (timed && nanos <= 0L) {
breakBarrier();
throw new TimeoutException();
}
}
} finally {
lock.unlock();
}
}
//构造方法，当栅栏被开启时，barrierAction由最后一个到达栅栏的线程执行
public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
this.count = parties;
this.barrierCommand = barrierAction;
}
// 构造方法
public CyclicBarrier(int parties) {
this(parties, null);
}
// 获取打开栅栏所需的线程数量，就是我们初始化时候指定的那个int参数
public int getParties() {
return parties;
}
// 调用这个方法的线程已经就绪等待了
public int await() throws InterruptedException, BrokenBarrierException {
try {
return dowait(false, 0L);
} catch (TimeoutException toe) {
throw new Error(toe); // cannot happen
}
}
// 这个方法是目标线程调用的，表示调用此方法的线程已经就绪等待着，
// 如果等待时间超过unit，就不等了，直接执行自己的
public int await(long timeout, TimeUnit unit)
throws InterruptedException,
BrokenBarrierException,
TimeoutException {
return dowait(true, unit.toNanos(timeout));
}
// 判断栅栏是否被破坏
public boolean isBroken() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return generation.broken;
} finally {
lock.unlock();
}
}
// 重置为初始化状态，如果此时有线程在等待，线程会抛出异常
public void reset() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
breakBarrier(); // break the current generation
nextGeneration(); // start a new generation
} finally {
lock.unlock();
}
}
// 获取当前正等待着的（或者说准备就绪了）线程的数量
public int getNumberWaiting() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return parties - count;
} finally {
lock.unlock();
}
}
}
来源：CSDN
作者：讲不出 再见
链接：https://blog.csdn.net/dgh112233/article/details/104649531