一、概述

Semaphore(信号量) 是一个线程同步结构，用于在线程间传递信号，以避免出现信号丢失，或者像锁一样用于保护一个关键区域，可以控制同时访问的线程个数，并且通过acquire()方法获取一个许可，如果没有则等待，而release()方法会释放一个许可。

二、应用场景

Semaphore可以用于做流量控制，特别公用资源有限的应用场景，比如数据库连接

三、使用方法

3.1、默认构造器

public Semaphore(int permits) {

sync = new NonfairSync(permits);

}

public Semaphore(int permits, boolean fair) {

sync = fair ? new FairSync(permits) : new NonfairSync(permits);

}

在上面两个构造器方法中，其中permits标识许可的数目，即可以同时允许多少个线程进行许可访问，而fair这个参数则表示是否是公平的，即等待时间越久的线程越能优先获得许可访问的权限。

3.2、重要方法

public void acquire() throws InterruptedException {

sync.acquireSharedInterruptibly(1);

}

public void acquire(int permits) throws InterruptedException {

if (permits < 0) throw new IllegalArgumentException();

sync.acquireSharedInterruptibly(permits);

}

public void release() {

sync.releaseShared(1);

}

public void release(int permits) {

if (permits < 0) throw new IllegalArgumentException();

sync.releaseShared(permits);

}

上面4个方法中，前两个表示获取许可，后两个表示释放许可，其中，acquire()用来获取一个许可，而acquire(int permits)则是用来获取permits个许可，如果暂时无许可可获取，则会一直等待，直到获得许可；release()表示释放许可，而release(int permits)则是表示释放permits个许可，另外在调用这两个方法的时候需要注意，在释放许可之前，必须要先获得许可才行。

除此之外，上面4个方法在被调用后都会出现阻塞，而如果我们想立即得到执行结果，则可以直接使用下面几个方法：

尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false。

/**

* 尝试获取一个许可，若获取成功，则立即

* 返回true，若获取失败，则立即返回false

*/

public boolean tryAcquire() {

return sync.nonfairTryAcquireShared(1) >= 0;

}

尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

/**

* 尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，* 否则则立即返回false

*/

public boolean tryAcquire(long timeout, TimeUnit unit)

throws InterruptedException {

return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));

}

尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false

/**

* 尝试获取permits个许可，若获取成功，则立即返回true，若获取失* 败，则立即返回false

*/

public boolean tryAcquire(int permits) {

if (permits < 0) throw new IllegalArgumentException();

return sync.nonfairTryAcquireShared(permits) >= 0;

}

尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

/**

* 尝试获取permits个许可，若在指定的时间内获取成功，则立即返回* true，否则则立即返回false

*/

public boolean tryAcquire(int permits, long timeout, TimeUnit unit)

throws InterruptedException {

if (permits < 0) throw new IllegalArgumentException();

return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));

}

3.3、其他方法

返回此信号量中当前可用的许可证数

public int availablePermits() {

return sync.getPermits();

}

返回正在等待获取许可证的线程数

public final int getQueueLength() {

return sync.getQueueLength();

}

是否有线程正在等待获取许可证

public final boolean hasQueuedThreads() {

return sync.hasQueuedThreads();

}

减少reduction个许可证。是个protected方法

protected void reducePermits(int reduction) {

if (reduction < 0) throw new IllegalArgumentException();

sync.reducePermits(reduction);

}

返回所有等待获取许可证的线程集合。是个protected方法

protected Collection getQueuedThreads() {

return sync.getQueuedThreads();

}

四、代码示例

我们假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么对于这样一种情况，我们就可以通过Semaphore来实现：

package com.feizi.java.concurrency.tool;

import java.util.concurrent.Semaphore;

/**

* Created by feizi on 2018/6/5.

*/

public class TestSemaphore {

public static void main(String[] args) {

//工人数

int N = 8;

//机器数目

Semaphore semaphore = new Semaphore(5);

for (int i = 0; i < N; i++){

new Worker(i, semaphore).start();

}

}

static class Worker extends Thread{

private int num;

private Semaphore semaphore;

public Worker(int num, Semaphore semaphore) {

this.num = num;

this.semaphore = semaphore;

}

@Override

public void run() {

try {

//通过信号量获取许可

semaphore.acquire();

System.out.println("工人 " + this.num + " 占用一个机器在生产...");

Thread.sleep(2000);

System.out.println("工人 " + this.num + " 释放出机器...");

//释放许可

semaphore.release();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

控制台输出结果：

工人 0 占用一个机器在生产...

工人 1 占用一个机器在生产...

工人 3 占用一个机器在生产...

工人 5 占用一个机器在生产...

工人 4 占用一个机器在生产...

工人 0 释放出机器...

工人 5 释放出机器...

工人 7 占用一个机器在生产...

工人 4 释放出机器...

工人 1 释放出机器...

工人 3 释放出机器...

工人 6 占用一个机器在生产...

工人 2 占用一个机器在生产...

工人 7 释放出机器...

工人 6 释放出机器...

工人 2 释放出机器...

Process finished with exit code 0

从上面输出结果，我们可以看到，虽然有8个工人(即8个线程)，但是只有5台机器(即只允许5个工人同时工作，也就是5个线程并发的执行)。

Semaphore的构造方法Semaphore(int permits)接收一个整型的参数，表示可用的许可证数量。Semaphore(5)表示只允许5个线程获取许可证，也就是最大并发数是5。而在使用的时候，是首先使用Semaphore的acquire()获取一个许可证，使用完之后调用release()归还许可证。

某种程度上，我们暂时可以简单地理解成锁，因为和锁的机制有些类似，一般用于控制对某组资源的访问权限。

五、原文参考