AQS的Semaphore

今天我们来聊一聊AQS家族中另一个重要成员Semaphore，我只收集到了一道关于Semaphore的面试题，问了问“是什么”和“如何实现的”：

• 什么是Semaphore？它是如何实现的？

按照我们的惯例，依旧是按照“是什么”，“怎么用”和“如何实现的”这3步来分析Semaphore。另外，今天提供了题解。

Semaphore的使用

Semaphore直译过来是信号量，是计算机科学中非常Old School的处理同步与互斥的机制，与互斥锁不同的是它允许指定数量的线程或进程访问共享资源。

Semaphore处理同步与互斥的机制和我们平时过地铁站的闸机非常相似。刷卡打开闸机（acquire操作），通过后（访问临界区）闸机关闭（release操作），后面的人才能够继续刷卡，而在前一个人通过前，后面的人只能排队等候（队列机制）。当然，地铁站不可能只有一个闸机，拥有几个闸机，就允许几个人同时通过。

信号量也是这样的，通过构造函数定义许可数量，使用时申请许可，处理完业务逻辑后释放许可：

// 信号量中定义1个许可
Semaphore semaphore = new Semaphore(1);

// 申请许可
semaphore.acquire();

......

// 释放许可
semaphore.release();

当我们为Semaphore定义一个许可时，它和互斥锁相同，同一时间只允许一个线程进入临界区。但是当我们定义了多个许可时，它与互斥锁的差异就体现出来了：

Semaphore semaphore = new Semaphore(3);
for(int i = 1; i < 5; i++) {
	int finalI = i;
	new Thread(()-> {
		try {
			semaphore.acquire();
			System.out.println("第[" + finalI + "]个线程获取到semaphore");
			TimeUnit.SECONDS.sleep(10);
			semaphore.release();
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}).start();
}

执行这段代码可以看到，同一时间3个线程都进入了临界区，只有第4个线程被挡在了临界区外。

Semaphore的实现原理

还记得在《AQS的今生，构建出JUC的基础》中提到的同步状态吗？我们当时说它是某些同步器的计数器：

AQS中，state不仅用作表示同步状态，也是某些同步器实现的计数器，如：Semaphore中允许通过的线程数量，ReentrantLock中可重入特性的实现，都依赖于state作为计数器的特性。

先来看Semaphore与AQS的关系：

与ReentrantLock一样，Semaphore内部实现了继承自AQS的同步器抽象类Sync，并有FairSync和NonfairSync两个实现类。接下来我们就通过剖析Semaphore的源码，来验证我们之前的说法。

构造方法

Semaphore提供了两个构造方法：

public Semaphore(int permits) {
sync = new NonfairSync(permits);
}

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

可以看到Semaphore和ReentrantLock的设计思路是一致的，Semaphore内部也实现了两个同步器FairSync和NonfairSync，分别实现公平模式和非公平模式，而Semaphore的构造本质上是构造同步器的实现。我们以非公平模式的NonfairSync的实现为例：

public class Semaphore implements java.io.Serializable {
	static final class NonfairSync extends Sync {
		NonfairSync(int permits) {
			super(permits);
		}
	}

	abstract static class Sync extends AbstractQueuedSynchronizer {
		Sync(int permits) {
			setState(permits);
		}
	}
}

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
	protected final void setState(int newState) {
		state = newState;
	}
}

追根溯源，构造器的参数permits最终还是回归到了AQS的state身上，借助了state作为计数器的特性来实现Semaphore的功能。

acquire方法

现在我们已经为Semaphore设置了一定数量的许可（permits），接下来我们就需要通过Semaphore#acquire方法获取许可，进入Semaphore所“守护”的临界区：

public class Semaphore implements java.io.Serializable {
	public void acquire() throws InterruptedException {
		sync.acquireSharedInterruptibly(1);
	}
}

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
	public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
		if (Thread.interrupted()) {
			throw new InterruptedException();
		}
		if (tryAcquireShared(arg) < 0) {
			doAcquireSharedInterruptibly(arg);
		}
	}
}

这两步和ReentrantLock非常相似，先通过tryAcquireShared尝试直接获取许可，失败后通过doAcquireSharedInterruptibly加入到等待队列中。

Semaphore中直接获取许可的逻辑非常简单：

static final class NonfairSync extends Sync {
	protected int tryAcquireShared(int acquires) {
		return nonfairTryAcquireShared(acquires);
	}
}

abstract static class Sync extends AbstractQueuedSynchronizer {
	final int nonfairTryAcquireShared(int acquires) {
		for (;;) {
			// 获取可用许可数量
			int available = getState();
			// 计算许可数量
			int remaining = available - acquires;
			if (remaining < 0 || compareAndSetState(available, remaining)) {
				return remaining;
			}
		}
	}
}

首先是获取并减少可用许可的数量，当许可数量小于0时返回一个负数，或通过CAS更新许可数量成功后，返回一个正数。此时doAcquireSharedInterruptibly会将当前的申请Semaphore许可的线程添加到AQS的等待队列中。

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {    
	private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
		// 创建共享模式的等待节点
		final Node node = addWaiter(Node.SHARED);
		try {
			for (;;) {
				final Node p = node.predecessor();
				if (p == head) {
					// 再次尝试获取许可，并返回剩余许可数量
					int r = tryAcquireShared(arg);
					if (r >= 0) {
						// 获取成功，更新头节点
						setHeadAndPropagate(node, r);
						p.next = null;
						return;
					}
				}
				// 获取失败进入等待状态
				if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {
					throw new InterruptedException();
				}
			}
		} catch (Throwable t) {
			cancelAcquire(node);
			throw t;
		}
	}
}

Semaphore的使用的doAcquireSharedInterruptibly与ReentrantLock使用的acquireQueued方法核心逻辑一直，但是有细微的实现差别：

• 创建节点使用Node.SHARED模式；
• 更新头节点使用了setHeadAndPropagate方法。

private void setHeadAndPropagate(Node node, int propagate) {
	Node h = head;
	setHead(node);

	// 是否要唤醒等待中的节点
	if (propagate > 0 || h == null || h.waitStatus < 0 || (h = head) == null || h.waitStatus < 0) {
		Node s = node.next;
		if (s == null || s.isShared()) {
			// 唤醒等待中的节点
			doReleaseShared();
		}
	}
}

我们知道在ReentrantLock中执行acquireQueued，当成功获取锁后，只需要执行setHead(node)即可，那么为什么Semaphore还要再进行唤醒？

假设有3个许可的Semaphore同时有T1，T2，T3和T4总计4个线程竞争：

• 它们同时进入nonfairTryAcquireShared方法，假设只有T1通过compareAndSetState(available, remaining)成功修改有效的许可数量，T1进入临界区；
• T2，T3和T4进入doAcquireSharedInterruptibly方法，通过addWaiter(Node.SHARED)构建出AQS的等待队列（参考AQS的今生中关于addWaiter方法的分析）；
• 假设T2成为了头节点的直接后继节点，T2再次执行tryAcquireShared尝试获取许可，T3和T4执行parkAndCheckInterrupt；
• T2成功获取许可并进入临界区，此时Semaphore剩余1个许可，而T3和T4处于暂停状态中。

这种场景中，只有两个许可产生了作用，显然不符合我们对的初衷，因此在执行setHeadAndPropagate更新头节点时，判断剩余许可的数量，当数量大于0时继续唤醒后继节点。

Tips：

• Semaphore在获取许可的流程与ReentrantLock加锁的过程高度相似~~
• 下文分析doReleaseShared是如何唤醒等待中节点的。

release方法

Semaphore的release方法就非常简单了：

public class Semaphore implements java.io.Serializable {
	public void release() {
		sync.releaseShared(1);
	}

	abstract static class Sync extends AbstractQueuedSynchronizer {
		protected final boolean tryReleaseShared(int releases) {
			for (;;) {
				int current = getState();
				// 计算许可数量
				int next = current + releases;
				if (next < current) {
					throw new Error("Maximum permit count exceeded");
				}
				// 通过CAS更新许可数量
				if (compareAndSetState(current, next)) {
					return true;
				}
			}
		}
	}
}

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
	public final boolean releaseShared(int arg) {
		if (tryReleaseShared(arg)) {
			doReleaseShared();
			return true;
		}
		return false;
	}

	private void doReleaseShared() {
		for (;;) {
			Node h = head;
			// 判断AQS的等待队列是否为空
			if (h != null && h != tail) {
				int ws = h.waitStatus;
				// 判断当前节点是否处于待唤醒的状态
				if (ws == Node.SIGNAL) {
					if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0)){
						continue;
					}
					unparkSuccessor(h);
				} else if (ws == 0 && !h.compareAndSetWaitStatus(0, Node.PROPAGATE)) {
					// 状态为0时，更新节点的状态为无条件传播
					continue;
				}
			}
			if (h == head) {
				break;
			}
		}
	}
}

我们可以看到Semaphore的release方法分了两部分：

• tryReleaseShared方法更新Semaphore的有效许可数量；
• doReleaseShared唤醒处于等待中的节点。

唤醒的逻辑并不复杂，依旧是对节点状态waitStatus的判断，来确定是否需要执行unparkSuccessor，当状态为ws == 0，会将节点的状态更新为Node.PROPAGAT，即无条件传播。

Tips：与ReentrantLock所不同的是，Semaphore并不支持Node.CONDITION状态，同样的ReentrantLock也不支持Node.PROPAGATE状态。

结语

关于Semaphore的内容到这里就结束了，今天我们只具体分析了非公平模式下核心方法的实现，至于公平模式的实现，以及其它方法的实现，就留个大家自行探索了。

好了，希望本文能够带给你一些帮助，我们下次再见！最后欢迎大家关注王有志的专栏《Java面试都问啥？》。