JAVA多线程-Semaphore信号量
一、概述
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<Thread> 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()归还许可证。
某种程度上，我们暂时可以简单地理解成锁，因为和锁的机制有些类似，一般用于控制对某组资源的访问权限。
五、原文参考
