java多线程之Semaphore使用

        本文将介绍用来控制资源同时访问个数的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时,它关注的是某一个资源最多同时能被几个线程访问。

 

文章来源：http://mouselearnjava.iteye.com/blog/1921468