Semaphore，信号量，是用来控制并发数量的有效手段。通常我们可以把他理解成一个带有固定容量许可的池子。当需要做一件事情，首先需要向池子里申请许可（permit）。当池子中还有空闲许可的时候，可以申请成功，获得许可，意味着可以接下来执行要的事情，否则会阻塞直到获得腾出来的许可。当执行完操作时，需要释放掉许可。 申请许可 和 释放许可 对应方法：acquire和release。acquire可以申请多个，同样的release也可以释放多个。但是注意，释放超过申请的，会使得整个许可集中许可的数量变多。另外，可以通过tryAcquire的几个方法来尝试获取许可，见下文代码示例：
package org.zheng.multithread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 信号量
* Create by zxb on 2017/4/26
*/
public class SemaphoreTest {
private static final int THREAD_COUNT = 5;
private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
private static Semaphore s = new Semaphore(3);
/**
* tryAcquire()
* 尝试获取permits个许可，成功则返回true，失败则返回false
*
* @throws InterruptedException
*/
public static void testTryAcquire1() throws InterruptedException {
if (s.tryAcquire()) { //尝试获取一个许可
System.out.println(Thread.currentThread().getName() + " 获得许可");
Thread.sleep(1500);
System.out.println(Thread.currentThread().getName() + " 操作完毕");
s.release(); //释放许可证
} else {
System.out.println(Thread.currentThread().getName() + "未获得许可");
}
}
/**
* tryAcquire(int permits)
* 尝试获取permits个许可，成功则返回true，失败则返回false
*
* @throws InterruptedException
*/
public static void testTryAcquire2() throws InterruptedException {
if (s.tryAcquire(1)) { //尝试获取一个许可
System.out.println(Thread.currentThread().getName() + " 获得许可");
Thread.sleep(1500);
System.out.println(Thread.currentThread().getName() + " 操作完毕");
s.release(); //释放许可证
} else {
System.out.println(Thread.currentThread().getName() + "未获得许可");
}
}
/**
* tryAcquire(long timeout, TimeUnit unit)
* 设置超时时间内能获取到1个许可都会返回true，否则返回false
*
* @throws InterruptedException
*/
public static void testTryAcquire3() throws InterruptedException {
if (s.tryAcquire(1, TimeUnit.SECONDS)) { //尝试获取一个许可，超时时间1s
System.out.println(Thread.currentThread().getName() + " 获得许可");
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName() + " 操作完毕");
s.release(); //释放许可证
} else {
System.out.println(Thread.currentThread().getName() + "未获得许可");
}
}
/**
* 不断尝试，直到都获取到信号量执行任务
*
* @throws InterruptedException
*/
public static void testTryAcquire4() throws InterruptedException {
while (true) {
if (s.tryAcquire(1, TimeUnit.SECONDS)) {
System.out.println(Thread.currentThread().getName() + " 获得许可");
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName() + " 操作完毕");
s.release(); //释放许可证
break;
}
}
}
/**
* 常规用法，先获取，获取不到则阻塞线程执行，获取到执行完，释放信号量
*
* @throws InterruptedException
*/
public static void testAcquire() throws InterruptedException {
s.acquire(); //获取许可
System.out.println(Thread.currentThread().getName() + " 获得许可");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " 操作完毕");
s.release(); //释放许可，只需要释放一次，释放多次会让信号量多增加
}
public static void main(String[] args) {
for (int i = 0; i < THREAD_COUNT; i++) {
threadPool.execute(new Runnable() {
@Override
public void run() {
try {
// testTryAcquire1();
// testTryAcquire2();
// testTryAcquire3();
// testTryAcquire4();
testAcquire();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
threadPool.shutdown();
}
}
执行结果：
信号量的作用可以看到，同时最多3个线程在跑，其他2个线程就阻塞在等待获取中，当有释放许可，可以立即被等待线程获取到，然后继续进行操作。
