本文将介绍用来控制资源同时访问个数的Semaphore工具类，然后采用Semaphore给出一个泊车的实例，最后给出Semaphore和CountDownLatch的几点比较。
一. Semaphore工具类介绍
/**
* A counting semaphore. Conceptually, a semaphore maintains a set of
* permits. Each {@link #acquire} blocks if necessary until a permit is
* available, and then takes it. Each {@link #release} adds a permit,
* potentially releasing a blocking acquirer.
* However, no actual permit objects are used; the <tt>Semaphore</tt> just
* keeps a count of the number available and acts accordingly.
*
* <p>Semaphores are often used to restrict the number of threads than can
* access some (physical or logical) resource.
*/
从Semaphore的注释中可以看出如下几点:
1.从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。
2. Semaphore并不使用实际的许可对象，Semaphore 只对可用许可进行计数，并采取相应的行动。
3.Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。
Semaphore中定义了一个内部类Sync，该类继承AbstractQueuedSynchronizer。从代码中可以看出，Semaphore的方法基本上都调用了Sync的方法来实现。Smaphore还提供了公平和非公平的两种方式。
Semaphore工具类相关的类图如下：
二. Semaphore工具类的使用案例
下面给出的示例模拟30辆车去泊车，而车位有10个的场景。当车位满时，出来一辆车，才能有一辆车进入停车。
Car.java
package my.concurrent.semaphore;
import java.util.concurrent.Semaphore;
public class Car implements Runnable {
private final Semaphore parkingSlot;
private int carNo;
/**
* @param parkingSlot
* @param carName
*/
public Car(Semaphore parkingSlot, int carNo) {
this.parkingSlot = parkingSlot;
this.carNo = carNo;
}
public void run() {
try {
parkingSlot.acquire();
parking();
sleep(300);
parkingSlot.release();
leaving();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void parking() {
System.out.println(String.format("%d号车泊车", carNo));
}
private void leaving() {
System.out.println(String.format("%d号车离开车位", carNo));
}
private static void sleep(long millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
ParkingCars.java
package my.concurrent.semaphore;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class ParkingCars {
private static final int NUMBER_OF_CARS = 30;
private static final int NUMBER_OF_PARKING_SLOT = 10;
public static void main(String[] args) {
/*
* 采用FIFO, 设置true
*/
Semaphore parkingSlot = new Semaphore(NUMBER_OF_PARKING_SLOT, true);
ExecutorService service = Executors.newCachedThreadPool();
for (int carNo = 1; carNo <= NUMBER_OF_CARS; carNo++) {
service.execute(new Car(parkingSlot, carNo));
}
sleep(3000);
service.shutdown();
/*
* 输出还有几个可以用的资源数
*/
System.out.println(parkingSlot.availablePermits() + " 个停车位可以用!");
}
private static void sleep(long millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果：
4号车泊车 6号车泊车 8号车泊车 2号车泊车 10号车泊车 3号车泊车 5号车泊车 11号车泊车 1号车泊车 9号车泊车 4号车离开车位 13号车泊车 8号车离开车位 7号车泊车 2号车离开车位 15号车泊车 10号车离开车位 17号车泊车 6号车离开车位 12号车泊车 3号车离开车位 16号车泊车 14号车泊车 18号车泊车 11号车离开车位 5号车离开车位 1号车离开车位 19号车泊车 20号车泊车 9号车离开车位 13号车离开车位 21号车泊车 22号车泊车 7号车离开车位 15号车离开车位 23号车泊车 17号车离开车位 24号车泊车 12号车离开车位 25号车泊车 26号车泊车 14号车离开车位 27号车泊车 28号车泊车 16号车离开车位 20号车离开车位 29号车泊车 18号车离开车位 30号车泊车 19号车离开车位 21号车离开车位 23号车离开车位 22号车离开车位 26号车离开车位 24号车离开车位 28号车离开车位 30号车离开车位 25号车离开车位 27号车离开车位 29号车离开车位 10 个停车位可以用!
三. Semaphore vs. CountDownLatch
相同点：
两者都是用于线程同步的工具类，都通过定义了一个继承AbstractQueuedSynchronizer的内部类Sync来实现具体的功能。
不同点：
1.Semaphore提供了公平和非公平两种策略, 而CountDownLatch则不具备。
2.CountDownLatch： 一个或者是一部分线程，等待另外一部线程都完成操作。
Semaphorr：维护一个许可集.通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。
3.CountDownLatch中计数是不能被重置的。CountDownLatch适用于一次同步。当使用CountDownLatch时，任何线程允许多次调用countDown()。那些调用了await()方法的线程将被阻塞，直到那些没有被阻塞线程调用countDown()使计数到达0为止。
Semaphore允许线程获取许可, 未获得许可的线程需要等待.这样防止了在同一时间有太多的线程执行.Semaphore的值被获取到后是可以释放的，并不像CountDownLatch那样一直减到0。
4.使用CountDownLatch时，它关注的一个线程或者多个线程需要在其它在一组线程完成操作之后，在去做一些事情。比如：服务的启动等。使用Semaphore时,它关注的是某一个资源最多同时能被几个线程访问。