多线程分析之Semaphore
Semaphore分析由来
网上看了许多讲解Semaphore的，用Semaphore来实现顺序打印字母，但是可能大家都没有清楚具体的原因，所以来给大家分析下为什么可以使用Semaphore来实现顺序打印字母顺序。
Semaphore源码分析
先打开JDK8源码中的Semaphore，可以看到Semaphore是通过继承AQS来现实功能（AQS，Doug Lea大神重写并发包的核心，这个默认自己看过哈，其实蛮简单，核心原理：通过模板方法，完成流程调用，让子类实现具体方法，然后实现不同功能）。
说正事，我们贴出一张Semaphore的层级关系图。
在Semaphore中主要是Sync类实现AbstractQueuedSynchronizer，然后Sync又有两个实现类，分别是FaireSync和NonfairSync，即公平锁和非公平锁。我们来看下Sync中的部分源码：
/**
* Synchronization implementation for semaphore. Uses AQS state
* to represent permits. Subclassed into fair and nonfair
* versions. （使用AQS的state变量来代表许可，注释这段还是蛮重要）
*/
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 1192457210091910933L;
// 在构造函数中传入许可数
Sync(int permits) {
setState(permits);
}
// 获取许可数量
final int getPermits() {
return getState();
}
// 非公平锁获取许可方式
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
// 归还许可，更新可用许可数量
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;
}
}
// 减少许可， 获取时需要减少许可数量
final void reducePermits(int reductions) {
for (;;) {
int current = getState();
int next = current - reductions;
if (next > current) // underflow
throw new Error("Permit count underflow");
if (compareAndSetState(current, next))
return;
}
}
}
在类中，没有特别难的方法，都是都过CAS来进行操作，用AQS中的state来当作许可。好了， 有了这一部分基础，我们可以去看看大家是如何使用Semaphore来实现顺序打印的。还是先为大家贴上代码：
/** * <br>使用信号量顺序打印</br> * * @author lifacheng * @version 1.0 * @date 2019/6/18 11:08 * @since 1.0 */ public class Thread11 { private static Semaphore semaphore1 = new Semaphore(0); private static Semaphore semaphore2 = new Semaphore(1); Thread t1, t2; int count = 10; public Thread11() { t1 = new Thread() { public void run() { try { int i = 0; while(i++ < count) { //获得许可 semaphore2.acquire(); System.out.print("A"); //初始化许可为0，处于阻塞，当release获取许可、 semaphore1.release(); } } catch (Exception e) { e.printStackTrace(); } } }; t2 = new Thread() { public void run() { try { int i = 0; while(i++ < count) { semaphore1.acquire(); System.out.print("B"); semaphore2.release(); } } catch (InterruptedException e) { e.printStackTrace(); } } }; } public void run() { t1.start(); t2.start(); } public static void main(String args[]) throws Exception { Thread11 t = new Thread11(); t.run(); } }
在代码一开始，初始化了两个信号量，分别为：semaphore1，semaphore2，semaphore1的许可书为0个，semaphore2的许可书为1个。
acquire()源码分析
在线程t1的run()方法中，semaphore2执行了acquire()方法，我们打开源码看看这段逻辑是什么，
代码调用了sync中的acquireSharedInterruptibly()方法，此时我们要注意，传入的参数是1个（这个很重要）。我们接着往下找，找到这个是AQS中实现的方法。
我们找到具体的实现类中的方法，即tryAcquireShare(arg)这个在Semaphore中实现的方法。（在tryAcquireShare(arg)<0时，会进去doAcquireSharedInterruptibly()方法中，当获取小于0会处于阻塞状态）
）
我们可以看到有Semaphore有两个实现类，分别是公平和非公平两种实现，我们点进去看看到底有何不同。
公平：
非公平：
我们看到，公平就比非公平多了一个判断，这个判断就是判断是否是头节点（就不点进去看了哈）。
至此，我们可以看到，acquire()方法具体实现就是获取了一个许可。我们接着看代码，然后输出字符A，semaphore1执行了release()方法。
release()方法分析
我们点进release方法查看，
按照和acquire()的相同的逻辑，最后找到如上这段代码，即在执行release()方法时，会增加1个许可。
代码逻辑
自此我们知道代码的逻辑了，来具体分析下代码。
当线程t1和t2同时开始运行，这个t1开始执行获取到许可，然后输出A，这是就算t2拿到CPU执行权，由于初始化许可数为0，这时acquire()方法获取不到许可，处于阻塞状态。只有当t1中的semaphore1执行了release()方法时，才会增加一个许可，t2获取到CPU执行权后才会执行。假设此时t1又获取到CPU执行权，但是由于只有一个许可，开始获取过许可，再此获取会失败，也会处于阻塞状态，只有t2线程中semaphore2执行了release()方法才会增加一个许可，然后t1才会再次获取成功并执行。
代码充分使用了许可数量来控制线程的执行，当线程执行时，相互唤醒，增加许可数量。有点像wait和notify的概念，但是更高级，我们可以增加semaphore来控制多个线程执行顺序。 这下次就分析清楚了，为什么初始化0个许可数的semaphore仍然可以用来控制。可以说相当神奇。我们也对AQS的强大有了一个小小的了解。
总结
AQS的强大一时半会说不清楚，希望大家多看看源码，结合百家之所长，来提升自己。
