简述：
CountDownLatch、Semaphore和CyclicBarrier都是并发编程常用、好用的工具类，不需要开发人员使用底层的api，例如join()，可以通过CountDownLatch代替，开箱即用，减少使用底层api出错的可能，而且功能更加强大，CountDownLatch和Semaphore直接实现了AQS进而实现功能，而CyclicBarrier通过ReentrantLock实现，而ReentrantLock也是通过AQS实现，所以归根结底这三个工具类都是AQS实现。不了解AQS的请参考下面的连接，这里不会过多介绍AQS实现
AbstractQueuedSynchronizer源码(上)–排他锁
AbstractQueuedSynchronizer源码(下)–共享锁和Condition条件队列
ReentrantLock源码解析
CountDownLatch
CountDownLatch我们一般称为闭锁或者计数器，内部通过计数器的实现功能，内部通过AQS实现，代码非常简单，主要有两种应用场景：
1.让一个或多个线程等待其他线程操作完成后再继续执行，就是join()的思想。
2.让多个线程执行到锁的位置（await()代码位置）停止，通过countdown()统一释放。
原理图：
先写一下demo，然后再查看源码实现。
demo：
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch1 = new CountDownLatch(5);
CountDownLatch latch2 = new CountDownLatch(1);
for (int i = 0; i < 5; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName()+"启动成功");
try {
//这里保证多个线程同时执行后续代码，是前面提到的第二种场景
latch2.await();
System.out.println(Thread.currentThread().getName()+"执行代码逻辑");
latch1.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
System.out.println("Main开始执行");
Thread.sleep(1000);
latch2.countDown();
//主线程等待其他线程执行完成继续执行，第一种使用场景
latch1.await();
System.out.println("Main结束执行");
}
Thread-0启动成功
Thread-2启动成功
Thread-1启动成功
Thread-3启动成功
Main开始执行
Thread-4启动成功
Thread-0执行代码逻辑
Thread-2执行代码逻辑
Thread-1执行代码逻辑
Thread-3执行代码逻辑
Thread-4执行代码逻辑
Main结束执行
上面demo是CountDownLatch的两种简单适用场景，下面看下重要的方法实现。
await():
//①Sync为静态内部类，实现了AQS
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
//②
Sync(int count) {
setState(count);
}
//③
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
//④
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
//⑤
if (tryAcquireShared(arg) < 0)
//⑦
doAcquireSharedInterruptibly(arg);
}
//⑥
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
上面是await()方法的实现方式，我们一步步看下：
①.通过构造函数设置计数器count的值
②.将count赋值给AQS中state变量
③.调用await()，获取可中断的共享锁
④.相应中断，尝试获取共享锁(判断当前state是否为0)，如果失败，直接调用AQS中doAcquireSharedInterruptibly()，基本步骤是：将当前线程生成共享节点加入到队列尾部，然后判断当前节点是否为head的后驱节点，true，尝试获取共享锁，成功将自己设置为head，并且唤醒后续的节点，false，将node对应的前驱结点的状态设置为signal，然后阻塞自己，直到被唤醒。
所以整体的思路是：给state设置>0的值，await()就能让线程加入队列阻塞，实现await()功能。
countDown()：
//java
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
//尝试释放共享锁
if (tryReleaseShared(arg)) {
//调用AQS中的方法，从head节点开始唤醒状态为signal，及其后面的符合条件的节点
doReleaseShared();
return true;
}
return false;
}
//代码很简单，就不描述了
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
到这里，我们了解了闭锁的两个关键方法，通过AQS实现比较简单，通过简单的demo介绍了CountDownLatch的适用场景，对其有了基本的了解。
Semaphore：
Semaphore也就是信号量，一般用来控制当前资源的访问并发数，就像春运坐火车安检，每条通道的安检人员每次只放进去几个人，而Semaphore也是一样的，根据设置的permits设置每次允许通过的线程个数，设置每次acquire几个permits，释放几个permits。
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newCachedThreadPool();
CountDownLatch countDownLatch = new CountDownLatch(200);
Semaphore semaphore = new Semaphore(3);
for (int i = 0; i < 200; i++) {
executorService.execute(() -> {
try {
semaphore.acquire();
log.info("线程：{}do something",Thread.currentThread().getName());
Thread.sleep(1000);
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
countDownLatch.countDown();
}
});
}
countDownLatch.await();
executorService.shutdown();
log.info("finish");
}
上面运行代码的过程中可以看到，日志每3个打印一次，代码设置每次有3个permits，一个线程每次acquire 1个permits，所以可以有3个线程获得permits，休眠1s，然后release permits，所以最终出现日志每次打印3行代码。
类定义：
//Sync为静态内部类实现AQS
private final Sync sync;
//默认非公平锁
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
//fair对应是否公平锁
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
FairSync和NonFairSync
static final class NonfairSync extends Sync {
private static final long serialVersionUID = -2694183684443567898L;
NonfairSync(int permits) {
super(permits);
}
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
}
static final class FairSync extends Sync {
private static final long serialVersionUID = 2014338818796000944L;
FairSync(int permits) {
super(permits);
}
protected int tryAcquireShared(int acquires) {
for (;;) {
//判断是否有前驱节点，如果有，返回-1
if (hasQueuedPredecessors())
return -1;
//得到当前state变量值
int available = getState();
int remaining = available - acquires;
//如果当前持有锁的余额不足，或者CAS设置成功，直接返回，remaining>0说明可以acquire，否则被阻塞
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
FairSync和NonFairSync是Sync的两个子类，对应着公平锁和非公平锁的版本，两个类的构造函数都是讲permits设置到AQS的State变量，然后就是tryAcquireShared的区别，公平锁获取会判断同步队列中是否有前驱节点，如果有，秉承着FIFO的特性，返回-1，其余代码和非公平锁一致。
acquire()：
//每次获取1一个permits
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
//每次获取预设个人的permits
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//响应中断
if (Thread.interrupted())
throw new InterruptedException();
//尝试获取锁，对应着FairSync和NonFairSync两种版本锁的方法，默认为非公平锁，可以通过构造函数设置选择公平锁
if (tryAcquireShared(arg) < 0)
//将当前线程加入同步队列尾部，自旋尝试获取锁(当前驱节点为head的时候可以尝试获取锁)，失败阻塞，等待被唤醒，被唤醒后还是尝试获取锁。
doAcquireSharedInterruptibly(arg);
}
release()释放许可
//release()及其重载方法release(int permits)
public void release() {
sync.releaseShared(1);
}
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
//释放arg个permits
public final boolean releaseShared(int arg) {
//尝试释放共享锁，失败返回false，成功，doReleaseShared()去释放锁，及其后面的节点
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
//尝试获取锁
protected final boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();
int next = current + releases;
//如果超过integer最大值，抛出异常
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
//如果CAS设置当前state为next成功，返回true
if (compareAndSetState(current, next))
return true;
}
}
//尝试获取锁之后，释放锁及后面的节点
private void doReleaseShared() {
//自旋
for (;;) {
Node h = head;
//当前队列至少两个节点
if (h != null && h != tail) {
int ws = h.waitStatus;
//如果head的waitStatus为signal
if (ws == Node.SIGNAL) {
//跳过第一次
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
//唤醒后面的节点
unparkSuccessor(h);
}
//如果ws为初始状态，CAS失败的跳过
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
//最终h和head还是相同的，直接break
//head可能发生变化，因为AQS获取锁和释放锁都会调用这个方法
if (h == head) // loop if head changed
break;
}
}
其余方法：
//查询当前许可的数量
public int availablePermits() {
return sync.getPermits();
}
//获取所有的permits，返回
public int drainPermits() {
return sync.drainPermits();
}
final int drainPermits() {
for (;;) {
int current = getState();
if (current == 0 || compareAndSetState(current, 0))
return current;
}
}
这道理，介绍了Semaphore的基本使用与源码实现，和CountDownLatch一样都是通过AQS实现特定的功能，但是使用方式又不同，得到的功能也不同，现在来对比一下，能够更加直观的了解。
CountDownLatch和Semaphore实现对比：
1.CountDownLatch：使用AQS共享锁
设置state：构造函数设置计数器
await()：通过判断当前state==0，if true放行，if false阻塞执行的线程，相当于一个栅栏。
countDown()：每次讲state-1，直到减为0，释放阻塞在同步队列中线程。
2.Semaphore：使用AQS共享锁，可选择公平锁，非公平锁
设置state：构造函数
acquire(int permits)：将state - permits> 0，if false，无法获得许可，阻塞到同步队列，if true，可以获得许可。
PS：acquire区分是否公平锁，release不区分
release(int permits)：将state + permits赋值给state，permits必须是正整数，然后释放阻塞在同步队列的线程。
举个栗子：
CountDownLatch：就像超市大减价，很多人排队等着早上开门，时间到了，8点开门(state=0)，然后人哗啦直接全部放行。
Semaphore：就像火车站安检，工作人员每次控制过去一个或几个人去通过安检，通过安检一个或几个人，然后又放行一个或几个人去安检。
CyclicBarrier
前面了解了CountDownLatch的基本使用，但是有个缺点，就是无法循环使用，当countDown()将计数器减到0时，释放所有阻塞线程，然后就没然后了，而CyclicBarrier同样是起到栅栏的作用，但是可以循环使用。CyclicBarrier的作用就是让线程之间相互等待，直到内部计数器减到0，释放所有阻塞线程。
举个栗子：
public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
System.out.println("先执行Runnable command");
});
for (int i = 0; i < 3; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "到达栅栏之前");
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "通过栅栏了");
}).start();
}
}
Thread-0到达栅栏之前
Thread-2到达栅栏之前
Thread-1到达栅栏之前
先执行Runnable command
Thread-0通过栅栏了
Thread-2通过栅栏了
Thread-1通过栅栏了
将CyclicBarrier的计数器设置为3，当三个线程都执行的await()，将计数器减为0，就会继续执行。如果设置Runnable指令，通过栅栏的时候，优先执行Runnable指令。
相关属性：
public class CyclicBarrier {
//Generation为CyclicBarrier内部的年代的概念
private static class Generation {
boolean broken = false;
}
//可重入锁
private final ReentrantLock lock = new ReentrantLock();
//condition实例
private final Condition trip = lock.newCondition();
//permit的条件
private final int parties;
//Runnable指令
private final Runnable barrierCommand;
//
private Generation generation = new Generation();
//计数器，初始等于parties
private int count;
//设置parties，Runnable指令
public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
this.count = parties;
this.barrierCommand = barrierAction;
}
//设置parties，也就是计数器的初始值
public CyclicBarrier(int parties) {
this(parties, null);
}
}
因为CyclicBarrier是可以重复使用的，满足条件通过栅栏，当通过之后，就是一个新的Generation。我们知道当通过栅栏的时候，会优先执行Runnable的Run()，这就是barrierCommand存在的意义。
await()：
public int await() throws InterruptedException, BrokenBarrierException {
try {
return dowait(false, 0L);
} catch (TimeoutException toe) {
throw new Error(toe); // cannot happen
}
}
public int await(long timeout, TimeUnit unit)
throws InterruptedException,
BrokenBarrierException,
TimeoutException {
return dowait(true, unit.toNanos(timeout));
}
await()是CyclicBarrier主要方法，线程调用每次讲计数器--count，直到等于0，然后通过condition.notifyAll()唤醒全部线程。当然Generation就是下一个新的年代了，一起看下dowait()的实现。
dowait()：
private int dowait(boolean timed, long nanos)
throws InterruptedException, BrokenBarrierException,
TimeoutException {
//获得lock，然后加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//获得当前generation
final Generation g = generation;
//年代是否被broken，默认为false，if true，抛出BrokenBarrierException
if (g.broken)
throw new BrokenBarrierException();
//是否被打断，如果打断，打断栅栏(将generation.broken设置为true，重置计数器，执行signalAll())，并且响应中断
if (Thread.interrupted()) {
breakBarrier();
throw new InterruptedException();
}
//每次count减1
int index = --count;
//如果计数器值count为0，或者说当前generation最终一个线程到达栅栏
if (index == 0) { // tripped
boolean ranAction = false;
try {
final Runnable command = barrierCommand;
//优先执行Runnable指令
if (command != null)
command.run();
ranAction = true;
//开启下个generation，执行signalAll()，唤醒之前等待的线程，重置计数器，generation重置初始化
nextGeneration();
return 0;
} finally {
//如果失败，将generation的broker设置为true，重置计数器，generation重置初始化。
if (!ranAction)
breakBarrier();
}
}
for (;;) {
try {
//如果没有设置timeout，调用await()阻塞在条件队列，直到被signal()/signalAll()唤醒，加入到同步队列，去获取锁
if (!timed)
trip.await();
//如果设置timeout，调用awaitNanos
else if (nanos > 0L)
nanos = trip.awaitNanos(nanos);
} catch (InterruptedException ie) {
//线程必须是当前generation，且broken为false
if (g == generation && ! g.broken) {
breakBarrier();
throw ie;
} else {
//如果不是当前generation的线程被中断，jvm认为已经完成任务，直接中断线程。
Thread.currentThread().interrupt();
}
}
//如果有任何一个线程breakBarrier，唤醒的线程，也必须抛出异常。
if (g.broken)
throw new BrokenBarrierException();
//判断是否是当前带
if (g != generation)
return index;
if (timed && nanos <= 0L) {
breakBarrier();
throw new TimeoutException();
}
}
} finally {
lock.unlock();
}
}
实现功能最重要的有两个概念，计数器count和年代generation，为什么需要generation呢？
因为同一个线程可以使用多个CyclicBarrier，如果没有generation，就无法区分了，所以通过generation判断年代是否发生变化，来保证栅栏的正确使用。
如果break被设置为true，其余线程被唤醒也是会判断break，最终导致这个CyclicBarrier就无法使用。
CountDownLatch和CyclicBarrier区别：
1.CountDownLatch只能使用一次，而CyclicBarrier的await()可以循环利用，或者使用reset()进行重置。
2.CyclicBarrier是多个线程之间相互等待，直到满足条件，打开栅栏，而CountDownLatch同样可以完成这样的功能，就是将CountDownLatch的计数器设置为1，通过await()去阻塞在栅栏，需要依赖外部的线程执行一次countDown()。
3.主线程需要等待其他线程执行完成之后继续执行的场景，这两个锁都是可以完成的。
4.如果不是循环使用的场景，lz认为CountDownLatch的使用能够更加灵活，所以更推荐的。