一、Semaphore 是什么
信号量Semaphore是一个并发工具类，用来控制可同时并发的线程数，其内部维护了一组虚拟许可，构造函数初始化的时候可以指定许可的总数量
每次线程执行操作时先通过acquire方法获得许可，线程获得许可后Semaphore 的许可数量会减1，执行完毕再通过release方法释放许可，emaphore 的许可数量会加1。如果无可用许可，那么acquire方法将一直阻塞，直到其它线程释放许可。
主要方法：
- Semaphore(int permits): 构造方法，创建具有给定许可数的计数信号量并设置为非公平信号量。
- Semaphore(int permits,boolean fair): 构造方法，当fair等于true时，创建具有给定许可数的计数信号量并设置为公平信号量。
- void acquire(): 从此信号量获取一个许可，如果没有获取到许可线程将一直阻塞。
- void acquire(int n): 从此信号量获取给定数目许可，在提供这些许可前一直将线程阻塞。
- void release(): 释放一个许可，将其返回给信号量。就如同车开走返回一个车位。
- void release(int n): 释放n个许可。
- int availablePermits()：当前可用的许可数
二、Semaphore 和线程池的区别
- 线程池：用来控制实际工作的线程数量，通过线程复用的方式来减小内存开销。线程池可同时工作的线程数量是一定的，超过该数量的线程需进入线程队列等待，直到有可用的工作线程来执行任务。
- Semaphore: 你创建了多少线程，实际就会有多少线程进行执行，只是可同时执行的线程数量会受到限制。但使用线程池，不管你创建多少线程，实际可执行的线程数是一定的。
示例程序：
package semaphore.demo; import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore; /**
* @author boshen
* @date 2018/12/20
*/
public class SemaphoreTest1 {
/**
* 用线程池来控制工作线程
*/
private static void testThreadPoll(){
ExecutorService executorService = Executors.newFixedThreadPool();
for(int i = ;i< ;i++)
executorService.submit(new Runnable() {
public void run() {
try {
String name = UUID.randomUUID().toString().substring(,);
System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());
Thread.sleep();
System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
executorService.shutdown();
} /**
* 用Semaphore来控制工作线程
*/
private static void testSemaphore(){
final Semaphore semaphore = new Semaphore();
for(int i=;i<;i++){
Thread thread = new Thread(new Runnable() {
public void run() {
try {
semaphore.acquire();
String name = UUID.randomUUID().toString().substring(,);
System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());
Thread.sleep();
System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
}
} public static void main(String[] args){
System.out.println("以下是testThreadPoll输出的结果============================================");
testThreadPoll();
try {
Thread.sleep();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("以下是testSemaphore输出的结果============================================");
testSemaphore();
}
}
以下是testThreadPoll输出的结果============================================
学生:14fd- 开始工作，线程号为：pool--thread-
学生:6bc6- 开始工作，线程号为：pool--thread-
学生:6bc6- 完成工作，线程号为：pool--thread-
学生:6a3b- 开始工作，线程号为：pool--thread-
学生:14fd- 完成工作，线程号为：pool--thread-
学生:9e7b- 开始工作，线程号为：pool--thread-
学生:6a3b- 完成工作，线程号为：pool--thread-
学生:2ed3- 开始工作，线程号为：pool--thread-
学生:9e7b- 完成工作，线程号为：pool--thread-
学生:2ed3- 完成工作，线程号为：pool--thread-
以下是testSemaphore输出的结果============================================
学生:- 开始工作，线程号为：Thread-
学生:99e9- 开始工作，线程号为：Thread-
学生:99e9- 完成工作，线程号为：Thread-
学生:- 完成工作，线程号为：Thread-
学生:b9a5- 开始工作，线程号为：Thread-
学生:058d- 开始工作，线程号为：Thread-
学生:b9a5- 完成工作，线程号为：Thread-
学生:7f6a-c 开始工作，线程号为：Thread-
学生:058d- 完成工作，线程号为：Thread-
学生:7f6a-c 完成工作，线程号为：Thread-
由以上结果可知当使用前线池的时候，同时只有2个线程执行工作，线程号只会有1和2，线程会进行复用；Semaphore虽然也只有2个线程能同时工作，但是线程号是0、1、2、3、4，也就是5个线程都执行了，只不过同一时刻有三个线程阻塞了而已。
三、Semaphore 公平信号量和非公平信号量
示例：
package semaphore.demo; import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore; /**
* @author boshen
* @date 2018/12/20
*/
public class SemaphoreTest2 {
/**
* 公平信号量
*/
private static void testFairSemaphore(){
final Semaphore semaphore1 = new Semaphore(,true);
for(int i=;i<;i++){
Thread thread = new Thread(new Runnable() {
public void run() {
try {
String name = UUID.randomUUID().toString().substring(,);
System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());
semaphore1.acquire();
Thread.sleep();
System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());
semaphore1.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
}
} /**
* 非公平信号量
*/
private static void testUnFairSemaphore(){
final Semaphore semaphore2 = new Semaphore();
for(int i=;i<;i++){
final Thread thread = new Thread(new Runnable() {
public void run() {
try {
String name = UUID.randomUUID().toString().substring(,);
System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());
semaphore2.acquire();
Thread.sleep();
System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());
semaphore2.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
}
} public static void main(String[] args){
System.out.println("以下是testFairSemaphore输出的结果============================================");
testFairSemaphore();
try {
Thread.sleep();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("以下是testUnFairSemaphore输出的结果============================================");
testUnFairSemaphore();
}
}
以下是testFairSemaphore输出的结果============================================
学生:81f2- 开始工作，线程号为：Thread-
学生:-d 开始工作，线程号为：Thread-
学生:e212-a 开始工作，线程号为：Thread-
学生:f059-d 开始工作，线程号为：Thread-
学生:9ece- 开始工作，线程号为：Thread-
学生:81f2- 完成工作，线程号为：Thread-
学生:e212-a 完成工作，线程号为：Thread-
学生:-d 完成工作，线程号为：Thread-
学生:f059-d 完成工作，线程号为：Thread-
学生:9ece- 完成工作，线程号为：Thread-
以下是testUnFairSemaphore输出的结果============================================
学生:- 开始工作，线程号为：Thread-
学生:- 开始工作，线程号为：Thread-
学生:e920- 开始工作，线程号为：Thread-
学生:be7a-f 开始工作，线程号为：Thread-
学生:e4fc-b 开始工作，线程号为：Thread-
学生:- 完成工作，线程号为：Thread-
学生:e920- 完成工作，线程号为：Thread-
学生:- 完成工作，线程号为：Thread-
学生:e4fc-b 完成工作，线程号为：Thread-
学生:be7a-f 完成工作，线程号为：Thread-
公平信号量的效果：哪信线程首先调用Semaphore.acquire（），哪个线程优先获得许可，首先启动的线程优先获取许可（不是100%，只是增加了概率）
非公平信号量的效果：是与线程的启动顺序与调用Semaphore.acquire（）顺序无关，也就是说先启动的线程并不一定先获得许可。