JUC——Semaphore

Semaphore信号量也是基于AQS共享模式来实现的，通过AQS的state完成计数器，它可以用来保护一个或多个共享资源的访问，如果state>0则允许获取资源，否则阻塞等待；

Semaphore支持公平式和非公平式抢占，默认为非公平式抢占，在创建Semaphore时，通过:

public Semaphore(int permits, boolean fair) {
	sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
1
2
3

Semaphore主要的方法 ：

• void acquire() ：从信号量获取一个许可，如果无可用许可前将一直阻塞等待
• void acquire(int permits) ：获取指定数目的许可，如果无可用许可前也将会一直阻塞等待
• boolean tryAcquire()：从信号量尝试获取一个许可，如果无可用许可，直接返回false，不会阻塞
• boolean tryAcquire(int permits)： 尝试获取指定数目的许可，如果无可用许可直接返回false
• boolean tryAcquire(int permits, long timeout, TimeUnit unit)： 在指定的时间内尝试从信号量中获取许可，如果在指定的时间内获取成功，返回true，否则返回false
• void release()： 释放一个许可
• int availablePermits()： 获取当前信号量可用的许可

1. 公平式信号量

获取许可

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);
}
// < 0 入队
protected int tryAcquireShared(int acquires) {
	for (;;) {
		// 判断是否需要排队，true需要
		if (hasQueuedPredecessors())
			return -1;
		// 如果不需要排队，则对state值进行扣减；
		int available = getState();
		int remaining = available - acquires;
		if (remaining < 0 ||
			compareAndSetState(available, remaining))
			return remaining;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

释放许可

public void release() {
	sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
	if (tryReleaseShared(arg)) {
		doReleaseShared();
		return true;
	}
	return false;
}
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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

从上面的源码中可以看出，在释放许可的时候，并没有做太多的限制，那如果acquire一次，release两次会有什么后果呢？

当多次调用release相当于会直接改变state的值，比如初始化Semaphore(5)时，相当于在改变5的限制；

2. 非公平式信号量

获取许可

protected int tryAcquireShared(int acquires) {
	return nonfairTryAcquireShared(acquires);
}
final int nonfairTryAcquireShared(int acquires) {
	for (;;) {
		// 这里并没有判断排队情况，而是直接去获取，就这么点区别
		int available = getState();
		int remaining = available - acquires;
		if (remaining < 0 ||
			compareAndSetState(available, remaining))
			return remaining;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13