java 线程调用_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 Semaphore just

* keeps a count of the number available and acts accordingly.

*

*

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时,它关注的是某一个资源最多同时能被几个线程访问。