前面《JUC并发核心AQS同步队列原理详解》介绍了AQS的同步等待队列的实现原理及源码分析，《ReentrantLock实现原理及源码分析》中介绍了AQS的同步队列独占模式实现的ReentranLock，这节将会介绍一下Semaphore、CountDownLatch和CyclicBarrier，并将会对源码进行分析。
一、Semaphore使用及源码分析
1、Semaphore的使用介绍
Semaphore也就是我们常说的信号量， Semaphore可以控制同时访问的线程个数，通过 acquire 获取一个许可，如果没有就等待，通过 release 释放一个许可。有点类似限流的作用，可以用来做简单的单机版的限流。
Semaphore的构造方法可以传入许可的数量，另外还可以传入一个boolean类型的参数用来执行公平、非公平模式，不传默认是非公平模式。
下面是一个简单的程序示例：信号量初始为2，两个共享资源三个线程竞争，开始只有两个线程可以获得许可往下执行，有一个线程在acquire的地方被阻塞，前面的线程任何一个调用release释放资源之后，阻塞的线程才可以继续往下执行。
public class SemaphoreTest {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(2);
for (int i=0;i<3;i++){
new Thread(()->{
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+":aquire() at time:"+System.currentTimeMillis());
Thread.sleep(5000);
semaphore.release();
System.out.println(Thread.currentThread().getName()+":release() at time:"+System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
},"Thread"+i).start();
}
}
}
输出如下：
Thread0:aquire() at time:1610780063431
Thread1:aquire() at time:1610780063432
Thread1:release() at time:1610780068433
Thread2:aquire() at time:1610780068433
Thread0:release() at time:1610780068433
Thread2:release() at time:1610780073434
2、Semaphore的源码分析
Semaphore是AQS同步队列的共享模式实现的，它的内部实现结构跟ReentrantLock很像，也是有一个内部类Sync，Sync是AbstractQueuedSynchronizer的子类，Sync有两个子类FairSync和NonFairSync，分别用来实现公平模式和非公平模式。
创建Semaphore 实例的时候，需要一个参数 permits，这个是设置给 AQS的state的，然后每个线程调用 acquire 的时候，执行 state = state 1，release 的时候执行的时候执行 state = state + 1。当然，acquire的的时候，如果 state = 0，说明没有资源了，需要等待其他线程 release。
注意：《JUC并发核心AQS同步队列原理详解》中关于AQS中的关键方法已经介绍过了，下面涉及AQS中的方法不再重复介绍。
1、构造方法分析：创建了一个非公平模式的NonfairSync对象，传入许可证数量。NonfairSync的构造方法中调用了父类Sync的构造，就是把state的值设置为许可证的数量。
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}NonfairSync(int permits) {
super(permits);
}Sync(int permits) {
setState(permits);
}
2、acquire方法源码分析
我们只分析下非公平模式的流程，公平模式的代码差别不大，唯一的区别就是公平模式时会先判断一下队列上是否有等待的线程，如果有会进行排队。acquire方法调用了AbstractQueuedSynchronizer中的acquireSharedInterruptibly
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
acquireSharedInterruptibly方法如下所示：会调用NonFairSync实现的tryAcquireShared方法，如果该方法返回值小于0即没有可用获取的许可证，会调用AQS中的doAcquireSharedInterruptibly方法进行排队等待
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
NonFairSync实现的tryAcquireShared方法如下所示：里面调用了父类Sync的nonfairTryAcquireShared方法
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
Sync的nonfairTryAcquireShared方法如下：获取当前state值即可用资源数量，然后通过当前数量-要获取数量计算出剩余的数量remaining，如果remaining小于0，说明获取资源失败，返回remaining的值，如果remaining>=0，则表示当前线程可以尝试获取资源，通过CAS的方式将state的值设置为remaining，如果CAS设置失败继续下一次循环，如果设置成功返回remaining的值（此时大于等于0）。
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
3、release方法源码分析
release方法会调用AQS中的releaseShared方法
public void release() {
sync.releaseShared(1);
}
AQS中的releaseShared方法：先调用Sync中重写的tryReleaseShared方法释放资源即减state的值，如果返回true，会调用AQS中的doReleaseShared方法，doReleaseShared方法会唤醒同步队列中被阻塞的线程，线程被唤醒后会继续尝试获取资源。
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
Sync中重写的tryReleaseShared方法： 获取当前state值current，将current加上释放的资源数量得到新值next，如果next<current说明求和得到的值超过了int的最大值导致溢出了，抛出异常；通过CAS的方式将state设置为新值，如果设置成功返回true，如果设置失败继续下一次循环。
protected final boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
二、CountDownLatch使用及源码分析
1、CountDownLatch的使用介绍
CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完毕再执行。从命名可以解读到countdown是倒数的意思，类似于我们倒计时的概念。
CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量，计数器的值也是通过state实现的。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
CountDownLatch常用方法：
-
CountDownLatch.countDown() 会将计数器数量减1
-
CountDownLatch.await() 计数器减到0之前，调用await方法的线程会一直阻塞
使用示例如下：
public class CountDownLatchTest {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(2);
for (int i = 0; i < 2; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"执行任务完成");
latch.countDown();
},"Thread"+i).start();
}//等待线程池中的2个任务执行完毕，否则一直阻塞等待
latch.await();
System.out.println("线程池任务执行结束，主线程继续执行");
}
}
控制台输出如下所示：可以看到线程池中任务执行完成之前，主线程一直在阻塞等待。
Thread1执行任务完成
Thread0执行任务完成
线程池任务执行结束，主线程继续执行
2、CountDownLatch的源码分析
CountDownLatch的源码结构其实跟上面的Semaphore差不多，主要区别在于其内部类Sync中重写的AQS中的tryAcquireShared和tryReleaseShared方法不一样，这里就不详细分析了。
await方法会调用tryAcquireShared方法：如果state为0则可以往下执行，如果state不为0，说明计数器还没有减到0，说明线程得排队阻塞。
countDown方法会调用tryReleaseShared方法：主要就是将state的值减1，如果减到0了则会唤醒队列中阻塞的线程。
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}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;
}
}
三、CyclicBarrier使用介绍
CyclicBarrier也称为栅栏屏障，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。CyclicBarrier默认的构造方法是CyclicBarrier（int parties），其参数表示屏障拦截的线程数量，每个线程调用await方法告CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
CyclicBarrier与CountDownLatch的功能比较相似，区别是CyclicBarrier的计数器可以重用。CyclicBarrier的构造方法会传一个数量parties，只有调用await的次数达到了parties时，await方法才会向下执行，否则调用await方法的地方会一直被阻塞。调用await的次数达到了parties后，线程继续向下执行，我们可以再次调用await方法，如果调用次数没有达到parties，会继续被阻塞，也就达到了计数器重用的功能。
下面通过一个程序示例演示一下：
public class CyclicBarrierDemo {
public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
CyclicBarrier cyclicBarrier = new CyclicBarrier(3, ()->{
System.out.println("所有任务都已经到达屏障，可以开始执行了");
});for (int i = 0; i < 2; i++) {
new Thread(()->{
try {
cyclicBarrier.await();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"执行了");
},"第一批Thread"+i).start();
}cyclicBarrier.await();
//休眠一下，防止输出打印混在一起
Thread.sleep(100L);
System.out.println("==========第一批任务都准备好了，主线程继续执行");
//休眠一下，防止输出打印混在一起
Thread.sleep(100L);for (int i = 0; i < 2; i++) {
new Thread(()->{
try {
cyclicBarrier.await();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"执行了");
},"第二批Thread"+i).start();
}cyclicBarrier.await();
//休眠一下，防止输出打印混在一起
Thread.sleep(100L);
System.out.println("--------------第二批任务都准备好了，主线程继续执行");
}
}
输出如下所示：通过输出结果，可以看到了CyclicBarrier的await方法阻塞线程及计数器重用的特性。
所有任务都已经到达屏障，可以开始执行了
第一批Thread1执行了
第一批Thread0执行了
==========第一批任务都准备好了，主线程继续执行
所有任务都已经到达屏障，可以开始执行了
第二批Thread1执行了
第二批Thread0执行了
--------------第二批任务都准备好了，主线程继续执行
关于CyclicBarrier的源码就不再介绍了，感兴趣的话可以自己查看分析一下。
550
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
