深入学习semaphore
深入学习semaphore
控制同时访问资源线程数
访问特定资源前，先使用acquire(1)获得许可，如果许可数量为0，该线程则一直阻塞，直到有可用许可。
访问资源后，使用release()释放许可。
demo:
import java.util.concurrent.Semaphore;
public class SemaphoreDemo {
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占用一个机器在生产...
工人2占用一个机器在生产...
工人1占用一个机器在生产...
工人3占用一个机器在生产...
工人5占用一个机器在生产...
工人2释放出机器
工人5释放出机器
工人1释放出机器
工人4占用一个机器在生产...
工人0释放出机器
工人6占用一个机器在生产...
工人7占用一个机器在生产...
工人3释放出机器
工人4释放出机器
工人7释放出机器
工人6释放出机器
构造方法：
public Semaphore(int permits) { //参数permits表示许可数目，即同时可以允许多少线程进行访问
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) { //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}
获取释放许可：
public void acquire() throws InterruptedException { } //获取一个许可
public void acquire(int permits) throws InterruptedException { } //获取permits个许可
public void release() { } //释放一个许可
public void release(int permits) { } //释放permits个许可
如果想立即得到执行结果，可以使用下面几个方法：
public boolean tryAcquire() { }; //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
源码分析：
获取许可：
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
代码继续往下走：
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
调用doAcquireSharedInterruptibly()方法：
/**
* Acquires in shared interruptible mode.
* @param arg the acquire argument
*/
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
非公平策略
acquire实现，核心代码如下：
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();//当前还有多少个资源可用
int remaining = available - acquires; //可用资源减去线程索取，如果少于0说明资源不够 进入下一轮循环，直到资源够
if (remaining < 0 ||
compareAndSetState(available, remaining))/CAS原子性操作
return remaining;
}
}
acquires值默认为1，表示尝试获取1个许可，remaining代表剩余的许可数。
如果remaining>0并且成功使用设置available,则获取成功.返回remaining
如果remaining < 0，表示目前没有剩余的许可.结束方法。当前线程进入AQS中的doAcquireSharedInterruptibly方法等待可用许可并挂起，直到被唤醒。
2.release实现，核心代码如下：
protected final boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
releases值默认为1，表示尝试释放1个许可，next 代表如果许可释放成功，可用许可的数量。
通过unsafe.compareAndSwapInt修改state的值，确保同一时刻只有一个线程可以释放成功。
许可释放成功，当前线程进入到AQS的doReleaseShared方法，唤醒队列中等待许可的线程。
公平策略
acquire实现，核心代码如下：
protected int tryAcquireShared(int acquires) {
for (;;) {
if (hasQueuedPredecessors())
return -1;
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
在获取前先检查当前节点是否有前继节点(公平性)
- release实现，和非公平策略一样。
