本篇文章将介绍Semaphore和Exchanger这两个并发工具类。
Semaphore
信号量（英语：Semaphore）又称为信号标，是一个同步对象，用于保持在0至指定最大值之间的一个计数值。当线程完成一次对该semaphore对象的等待（wait）时，该计数值减一；当线程完成一次对semaphore对象的释放（release）时，计数值加一。当计数值为0，则线程等待该semaphore对象不再能成功直至该semaphore对象变成signaled状态。semaphore对象的计数值大于0，为signaled状态；计数值等于0，为nonsignaled状态.
semaphore对象适用于控制一个仅支持有限个用户的共享资源，是一种不需要使用忙碌等待（busy waiting）的方法。 ----取自维基百科
Semaphore思想在分布式中也有应用，分布式限流就是典型的案例。现在举个小例子来使用Semaphore
案例
在等公交时，遇到人多的时候经常需要排队或者挤进去。
![]()
解决方案
利用Semaphore初始化5个许可，每次只能有5个玩家进入，当有玩家退出时，其他玩家才能进入。
先介绍下Semaphore的构造函数和一些方法吧。
Semaphore构造函数
public Semaphore(int permits)；
public Semaphore(int permits, boolean fair)；
第一个参数permits表示初始化的许可数量，第二个参数表示是否是公平的。
使用Semaphore(int permits)构造函数时，默认使用非公平的
Semaphore常用方法
public void acquire()；
public void release()；
acquire方法取得许可，release方法表示释放许可。
注：如果多次调用release方法，会增加许可。例如，初始化许可为0，这时调用了两个release方法，Semaphore的许可便会变成2
这两个是最常用的方法，其他的还有acquire相关的方法tryAcquire和acquireUninterruptibly这里就不介绍了。
代码
玩家类
定义一个实现Runnable接口的玩家类
public class Player implements Runnable{
private String playerName;
private Semaphore semaphore;
public Player(String playerName, Semaphore semaphore) {
this.playerName = playerName;
this.semaphore = semaphore;
}
@Override
public void run() {
try {
semaphore.acquire();
System.out.println(playerName+"进入，时间:"+LocalTime.now());
Thread.sleep((long) (3000 * Math.random()));
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(playerName+"退出");
semaphore.release();
}
}
}
通过构造函数Player传入玩家名称和Semaphore对象，run方法中先调用acquire方法取得许可，然后睡眠随机时间，最后在finally中调用release方法释放许可。
测试类
先来使用非公平的看看效果，使用非公平的就好比平时的挤公交，谁先在车门口谁先进。如下图（来源于网络）
![]()
现在来看看测试代码
public static void main(String[] args) throws IOException {
Semaphore semaphore = new Semaphore(5);
//Semaphore semaphore = new Semaphore(5,true);
ExecutorService service = Executors.newCachedThreadPool();
//模拟100个玩家排队
for (int i = 0; i < 100; i++) {
service.submit(new Player("玩家"+i,semaphore));
}
//关闭线程池
service.shutdown();
//判断线程池是否中断，没有则循环查看当前排队总人数
while (!service.isTerminated()){
System.out.println("当前排队总人数:"+semaphore.getQueueLength());
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
如果要切换成公平方式只需将上面初始化Semaphore改为下面的代码即可
Semaphore semaphore = new Semaphore(5,true);
Exchanger
Exchanger主要用于线程间的数据交换。 它提供了一个同步点，在这个同步点，两个线程可以交换数据。
这里写了个两个线程互相交换数据的简单例子，下面ExchangerRunnable在run方法中调用exchange方法将自己的数据传过去。
public class ExchangerRunnable implements Runnable {
private Object data;
private String name;
private Exchanger exchanger;
public ExchangerRunnable(String name, Exchanger exchanger, Object data) {
this.exchanger = exchanger;
this.name = name;
this.data = data;
}
public void run() {
try {
Object previous = this.data;
this.data = this.exchanger.exchange(previous);
System.out.println("名称:" + name + " 之前数据：" + previous + " ,交换之后数据：" + this.data);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
接下来看看测试代码
public class Case {
private static final Exchanger exchanger = new Exchanger();
private static ExecutorService service = Executors.newFixedThreadPool(2);
public static void main(String[] args) {
service.submit(new ExchangerRunnable("1", exchanger, "A"));
service.submit(new ExchangerRunnable("2", exchanger, "B"));
service.shutdown();
}
}
定义了只包含两个线程的线程池，然后创建提交两个ExchangerRunnable的类
- 线程名称为1的原始数据时A
- 线程名称为2的原始数据时B
运行测试代码，会得到如下结果
名称:2 之前数据：B ,交换之后数据：A
名称:1 之前数据：A ,交换之后数据：B
案例源代码地址：https://github.com/rainbowda/learnWay/tree/master/learnConcurrency/src/main/java/com/learnConcurrency/utils
欢迎fork、Star、Issue等，谢谢
