前言
线程并发系列文章：
Java 线程基础
Java 线程状态
Java “优雅”地中断线程-实践篇
Java “优雅”地中断线程-原理篇
真正理解Java Volatile的妙用
Java ThreadLocal你之前了解的可能有误
Java Unsafe/CAS/LockSupport 应用与原理
Java 并发"锁"的本质(一步步实现锁)
Java Synchronized实现互斥之应用与源码初探
Java 对象头分析与使用(Synchronized相关)
Java Synchronized 偏向锁/轻量级锁/重量级锁的演变过程
Java Synchronized 重量级锁原理深入剖析上(互斥篇)
Java Synchronized 重量级锁原理深入剖析下(同步篇)
Java并发之 AQS 深入解析(上)
Java并发之 AQS 深入解析(下)
Java Thread.sleep/Thread.join/Thread.yield/Object.wait/Condition.await 详解
Java 并发之 ReentrantLock 深入分析(与Synchronized区别)
Java 并发之 ReentrantReadWriteLock 深入分析
Java Semaphore/CountDownLatch/CyclicBarrier 深入解析(原理篇)
Java Semaphore/CountDownLatch/CyclicBarrier 深入解析(应用篇)
最详细的图文解析Java各种锁(终极篇)
线程池必懂系列
前面分析了基于AQS的独占锁ReentrantLock、共享锁/独占锁ReentrantReadWriteLock，它们内部都实现了Lock 接口。而AQS还有其它常用的子类封装器，它们虽然没有实现Lock接口，但可以用来做线程间的同步，接下来将要来深入了解它们。
通过本篇文章，你将了解到：
1、Semaphore 原理分析
2、CountDownLatch 原理分析
3、CyclicBarrier 原理分析
1、Semaphore 原理分析
场景引入
ReentrantReadWriteLock 里有读锁和写锁，其中读锁是共享锁，其核心是对AQS里的"state"变量进行操作，每获取一次锁，将state加1，释放锁将state减1。从这里可以看出，将state作为共享资源能够实现线程间的协作。
现在有个需求：资源是共享的，但是数量有限，因此没拿到资源的需要等待别人释放资源。
将state作为标记共享资源的数量，那么就有：
1、线程占有资源后将state减1，线程释放资源后将state加1。
2、若线程没拿到资源(资源都被其它线程占有了)，那么挂起等待。
3、线程释放资源后，唤醒其它等待该资源的线程。
这样子，不用synchronized+wait/notify与ReentrantLock+await/signal，也依然能够实现线程间同步。
具体到现实场景：
如停车场只能容纳一定数量的车子，当停车场停满了车(入场许可发放完了)，其它想进来的车子必须等待>有其它车从停车场开出(释放入场许可)。
Semaphore 构造
指定初始的许可个数：
#Semaphore.java
public Semaphore(int permits) {
//默认是非公平
sync = new NonfairSync(permits);
}
Sync(int permits) {
setState(permits);
}
可以看出许可的个数就是state的值。
Semaphore 占有许可
通过调用acquire(xx)占有许可：
#Semaphore.java
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
//交给AQS处理，可中断
sync.acquireSharedInterruptibly(permits);
}
#AbstractQueuedSynchronizer.java
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//发生了中断，直接返回
if (Thread.interrupted())
throw new InterruptedException();
//尝试修改state(减)
if (tryAcquireShared(arg) < 0)
//修改失败，则挂起等待
doAcquireSharedInterruptibly(arg);
}
每次可以占有多个许可，若占有成功则直接返回，否则挂起等待。
具体的操作state在tryAcquireShared(xx)里实现，此处以非公平模式说明：
#Semaphore.java
final int nonfairTryAcquireShared(int acquires) {
//死循环确保修改state成功，或者state已经获取完了
for (;;) {
//获取state
int available = getState();
//减少state
int remaining = available - acquires;
if (remaining < 0 ||
//CAS 操作
compareAndSetState(available, remaining))
return remaining;
}
}
Semaphore 释放许可
占有许可做了相应的任务后，就可以释放许可了。
通过调用release(xx)释放许可：
#Semaphore.java
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
//AQS 实现
sync.releaseShared(permits);
}
#AbstractQueuedSynchronizer.java
public final boolean releaseShared(int arg) {
//尝试修改state(加)
if (tryReleaseShared(arg)) {
//成功修改state，唤醒后继节点
doReleaseShared();
return true;
}
//修改失败
return false;
}
具体的操作state在tryReleaseShared(xx)里实现：
#Semaphore.java
protected final boolean tryReleaseShared(int releases) {
for (;;) {
//获取state
int current = getState();
//增加
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
//修改
if (compareAndSetState(current, next))
return true;
}
}
可以看出：
释放许可，增加state，占有许可，减少state。
另外，Semaphore 占有许可可分为公平与非公平模式，占有许可过程可中断/不可中断。
Semaphore 与Lock 区别
与ReentrantLock、ReentrantReadWriteLock 区别在于从不同的角度看待state:
1、ReentrantLock、ReentrantReadWriteLock 获取锁的过程是将state值增大，而Semaphore 占有许可是将state值减小。
2、ReentrantLock、ReentrantReadWriteLock 释放锁的过程是将state值减小，而Semaphore 释放许可是将state值增大。
3、这也是AQS的灵活之处，将具体的"state"锁代表的意义由子类实现，可实现不同场景的应用。
2、CountDownLatch 原理分析
场景引入
A、B、C三个线程协作：
A 等待B、C完成任务后再进行下一步操作。
这场景我们可能会想到用Thread.join()，A调用B.join()，C.join()，A阻塞等待，当B、C线程执行结束后唤醒A。这种方式虽然能够解决问题，但是有些不尽人意的地方：比如说A不一定要等待B、C执行完成，而是B、C中途完成某个任务后通知A；又比如，B、C线程不止执行一次任务，而是一定的次数后才会唤醒A，这个时候使用Thread.join() 就无法解决问题了。
而CountDownLatch 可以很好地解决这问题。
CountDownLatch 构造
#CountDownLatch.java
//初始化次数
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
Sync(int count) {
//设置state
setState(count);
}
可以看出，count的值最终反馈到state上。
CountDownLatch 等待
通过await(xx)等待state变为0：
#CountDownLatch.java
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
//超时返回
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
#AbstractQueuedSynchronizer.java
public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
throws InterruptedException {
//该方法响应中断
if (Thread.interrupted())
throw new InterruptedException();
//主要工作在tryAcquireShared(xx)里
return tryAcquireShared(arg) >= 0 ||
doAcquireSharedNanos(arg, nanosTimeout);
}
又是AQS的套路，具体的操作state在tryAcquireShared(xx)里实现：
#CountDownLatch.java
protected int tryAcquireShared(int acquires) {
//若state == 0，则返回1，否则-1
//外层判断>=0，说明当前state还有数量，则需要阻塞等待，否则不阻塞
return (getState() == 0) ? 1 : -1;
}
与其它子类实现的tryAcquireShared(xx)方法不同的是，CountDownLatch里的Sync并没有修改state的值，仅仅只是判断state?=0进而做具体的操作而已。
由此可知：CountDownLatch 是基于AQS的共享模式。
CountDownLatch 倒数计数
既然调用await(xx)可能会使得线程阻塞等待，那么势必有其它线程唤醒它，调用的方法即是countDown()：
#CountDownLatch.java
public void countDown() {
sync.releaseShared(1);
}
#AbstractQueuedSynchronizer.java
public final boolean releaseShared(int arg) {
//子类实现
if (tryReleaseShared(arg)) {
//AQS里实现，唤醒阻塞的线程
doReleaseShared();
return true;
}
return false;
}
同样的，具体的操作state在tryReleaseShared(xx)里实现：
#CountDownLatch.java
protected boolean tryReleaseShared(int releases) {
for (;;) {
//获取state
int c = getState();
//若当前state==0，说明已经没有可以释放的了
if (c == 0)
return false;
int nextc = c-1;
//CAS修改
if (compareAndSetState(c, nextc))
//说明可以唤醒其它线程了
return nextc == 0;
}
}
也即是说，当线程调用await(xx)阻塞后，其它线程通过countDown()修改state值，若是发现state最终变为0了，那么唤醒阻塞的线程。
用图表示CountDownLatch主要结构如下：
CountDownLatch 与其它AQS子类封装器的区别
前面已经分析了基于AQS的封装器：ReentrantLock、ReentrantReadWriteLock、Semaphore，它们对state值的修改包括增加与减少，而CountDownLatch 只是减小state的值，用以实现倒数计数的功能。
可类比场景如下：
1、田径运动场开始百米赛跑。
2、运动员在跑道上各就各位(多个线程调用await 阻塞等待)。
3、裁判喊倒数3、2、1(线程调用countDown)。
4、等待倒数结束，发令枪响，运动员就开始跑(线程被唤醒，继续做事)。
可以看出，运动员不会去干涉裁判的倒数(修改state值)。
3、CyclicBarrier 原理分析
场景引入
在CountDownLatch 场景里说到运动员需要裁判，想想可以不需要裁判吗？运动员之间自发倒数，倒数结束就一起跑。
更普遍的场景是：
1、几个驴友想去某个景点旅游，约定了在某个地方集合后再一起出发。
2、每个驴友到达集合点时打卡并看人都到齐了没，没到齐则等待。
3、若最后一个参与者过来后发现人到齐了，于是告诉大家不用等了，出发吧。
CyclicBarrier 可满足该场景的需求。
CyclicBarrier 构造
#CyclicBarrier.java
public CyclicBarrier(int parties, Runnable barrierAction) {
//必须要有参与者
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
//临时变量count
this.count = parties;
//参与者都到达了后执行的动作
this.barrierCommand = barrierAction;
}
可以看出，此处并没有AQS介入，也就是没有直接修改state。
CyclicBarrier是通过ReentrantLock + Condition 来实现线程间同步的：
#CyclicBarrier.java
//独占锁，为了互斥修改count
private final ReentrantLock lock = new ReentrantLock();
//线程等待条件
private final Condition trip = lock.newCondition();
//修改的共享变量
private int count;
CyclicBarrier 等待参与者
接着来分析，如何实现线程间的同步的。
#CyclicBarrier.java
public int await() throws InterruptedException, BrokenBarrierException {
try {
//实际调用doWait()，此处是不限时等待
return dowait(false, 0L);
} catch (TimeoutException toe) {
throw new Error(toe); // cannot happen
}
}
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();
}
//等待个数-1
int index = --count;
if (index == 0) {
//都到齐了，无需等待了
boolean ranAction = false;
try {
//执行既定的方法
final Runnable command = barrierCommand;
if (command != null)
command.run();
ranAction = true;
//开始下一轮
nextGeneration();
return 0;
} finally {
if (!ranAction)
breakBarrier();
}
}
//走到这，说明还需要等待
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 {
...
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();
}
}
线程先获取独占锁，然后修改count值，若发现修改后count !=0，那么还需要等待，等待借助的是Condition.await(xx)方法。
有等待，自然有唤醒的地方：
#CyclicBarrier.java
private void breakBarrier() {
//置为true，表示已经结束等待了
generation.broken = true;
//重置count，复用的关键
count = parties;
//唤醒其它在等待的线程
trip.signalAll();
}
用图表示，等待/唤醒过程如下：
CyclicBarrier与CountDownLatch 区别
看到这，你也许已经发现了CyclicBarrier 和CountDownLatch 实现的功能很相似，都是等待某个条件满足后再进行下一步的动作，两者不同之处在于：
1、CountDownLatch 参与的线程分为两类：一个是等待者，另一个是计数者；CyclicBarrier 参与的线程既是等待者，也是计数者。
2、CountDownLatch 完成一次完整的协作过程后不能再复用，CountDownLatch 可以复用(不用重新新建CountDownLatch 对象)。
3、CountDownLatch 的计数值与线程个数没有必然联系，CyclicBarrier 的初始计数值与线程个数一致。
4、CountDownLatch 基于AQS实现，CyclicBarrier 基于ReentrantLock&Condition实现(内部也是基于AQS)。
你可能还有疑惑，在下一篇应用篇将会重点体现两者区别。
下篇文章重点分析：Semaphore/CountDownLatch/CyclicBarrier 实际应用。
本文基于jdk1.8。
