1. Semaphore 定義
Semaphore 主要用于限量控制并發(fā)執(zhí)行代碼的工具類, 其內部通過 一個 permit 來進行定義并發(fā)執(zhí)行的數量, 其實可以理解為一個 限制數量的 ReadLock 獲取.
Semaphore 主要特點:
-
Semaphore 方法的實現通過 Sync(AQS的繼承類)代理來實現
2.支持公平與非公平模式, 都是在AQS的子類里面進行, 主要區(qū)分在 tryAcquire 里面
先看一個簡單的 demo
import org.apache.log4j.Logger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Created by xjk on 9/15/16.
*/
public class SemaphoreExample implements Runnable {
private static Logger logger = Logger.getLogger(SemaphoreExample.class);
private static final Semaphore semaphore = new Semaphore(3, true); // 初始化 Semaphore, 限流閥值 為3, 并且指定為公平模式
private static final AtomicInteger counter = new AtomicInteger(0);
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0; i < 5; i++) {
executorService.execute(new SemaphoreExample()); // 執(zhí)行 permit 的獲取,
}
executorService.shutdown();
}
public void run() {
while(counter.incrementAndGet() <= 5) { // Semaphore 被循環(huán)獲取 5次
try {
semaphore.acquire(); // 進行 permit 的獲取
} catch (InterruptedException e) {
logger.info("["+Thread.currentThread().getName()+"] Interrupted in acquire().");
}
logger.info("["+Thread.currentThread().getName()+"] semaphore acquired: "+counter.get());
semaphore.release();
}
}
}
執(zhí)行結果
[2017-02-12 15:27:12,973] INFO pool-1-thread-2 (SemaphoreExample.java:35) - [pool-1-thread-2] semaphore acquired: 2
[2017-02-12 15:27:12,973] INFO pool-1-thread-3 (SemaphoreExample.java:35) - [pool-1-thread-3] semaphore acquired: 3
[2017-02-12 15:27:12,973] INFO pool-1-thread-1 (SemaphoreExample.java:35) - [pool-1-thread-1] semaphore acquired: 2
[2017-02-12 15:27:12,978] INFO pool-1-thread-5 (SemaphoreExample.java:35) - [pool-1-thread-5] semaphore acquired: 7
[2017-02-12 15:27:12,978] INFO pool-1-thread-4 (SemaphoreExample.java:35) - [pool-1-thread-4] semaphore acquired: 6
執(zhí)行步驟:
上面的代碼不好直接看出, 但可以這樣理解, 有一段代碼, 再
2. Semaphore 構造函數
Semaphore 的功能均由內部類 NonfairSync, FairSync 代理來實現
/**
* 使用非公平版本構件 Semaphore
*/
public KSemaphore(int permits){
sync = new NonfairSync(permits);
}
/**
* 指定版本構件 Semaphore
*/
public KSemaphore(int permits, boolean fair){
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
3. Semaphore 內部類 Sync
/**
* Synchronization implementation for semaphore. Uses AQS state
* to represent permits. Subclassed into fair and nonfair
* versions
*/
/** AQS 的子類主要定義獲取釋放 lock */
abstract static class Sync extends KAbstractQueuedSynchronizer{
private static final long serialVersionUID = 1192457210091910933L;
/**
* 指定 permit 初始化 Semaphore
*/
Sync(int permits){
setState(permits);
}
/**
* 返回剩余 permit
*/
final int getPermits(){
return getState();
}
/**
* 獲取 permit
*/
final int nonfairTryAcquireShared(int acquires){
for(;;){
int available = getState();
int remaining = available - acquires; // 判斷獲取 acquires 的剩余 permit 數目
if(remaining < 0 ||
compareAndSetState(available, remaining)){ // cas改變 state
return remaining;
}
}
}
/**
* 釋放 lock
*/
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)){ // cas改變 state
return true;
}
}
}
final void reducePermits(int reductions){ // 減少 permits
for(;;){
int current = getState();
int next = current - reductions;
if(next > current){ // underflow
throw new Error(" Permit count underflow ");
}
if(compareAndSetState(current, next)){
return;
}
}
}
/** 將 permit 置為 0 */
final int drainPermits(){
for(;;){
int current = getState();
if(current == 0 || compareAndSetState(current, 0)){
return current;
}
}
}
}
4. Semaphore 內部類 FairSync, NonfairSync
這兩個類均繼承 Sync, 兩者的區(qū)別主要在于在獲取時判斷是否有線程在 AQS 的 Sync Queue 里面進行等待獲取
/**
* Nonfair version
*/
/** 非公平版本獲取 permit */
static final class NonfairSync extends Sync{
private static final long serialVersionUID = -2694183684443567898L;
NonfairSync(int permits) {
super(permits);
}
@Override
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
}
/**
* Fair version
*/
/** 公平版本獲取 permit */
static final class FairSync extends Sync{
private static final long serialVersionUID = 3245289457313211085L;
FairSync(int permits) {
super(permits);
}
/**
* 公平版本獲取 permit 主要看是否由前繼節(jié)點
*/
@Override
protected int tryAcquireShared(int acquires) {
for(;;){
if(hasQueuedPredecessors()){ // 1\. 判斷是否Sync Queue 里面是否有前繼節(jié)點
return -1;
}
int available = getState();
int remaining = available - acquires;
if(remaining < 0 ||
compareAndSetState(available, remaining)){ // 2\. cas 改變state
return remaining;
}
}
}
}
5. Semaphore permit 獲取方法
下面這些方法主要通過內部類 Sync, FairSync, NonFairSync 來進行實現
/**
* 調用 acquireSharedInterruptibly 響應中斷的方式獲取 permit
*/
public void acquire() throws InterruptedException{
sync.acquireSharedInterruptibly(1);
}
/**
* 調用 acquireUninterruptibly 非響應中斷的方式獲取 permit
*/
public void acquireUninterruptibly(){
sync.acquireShared(1);
}
/**
* 嘗試獲取 permit
*/
public boolean tryAcquire(){
return sync.nonfairTryAcquireShared(1) >= 0;
}
/**
* 嘗試的獲取 permit, 支持超時與中斷
*/
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException{
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
/**
* 支持中斷的獲取permit
*/
public void acquire(int permits) throws InterruptedException{
if(permits < 0){
throw new IllegalArgumentException();
}
sync.acquireSharedInterruptibly(permits);
}
/**
* 不響應中斷的獲取 permit
*/
public void acquireUninterruptibly(int permits){
if(permits < 0) throw new IllegalArgumentException();
sync.acquireShared(permits);
}
/**
* 嘗試獲取 permit
*/
public boolean tryAcquire(int permits){
if(permits < 0) throw new IllegalArgumentException();
return sync.nonfairTryAcquireShared(permits) >= 0;
}
/**
* 嘗試 支持超時機制, 支持中斷 的獲取 permit
*/
public boolean tryAcquire(int permits, long timout, TimeUnit unit) throws InterruptedException{
if(permits < 0) throw new IllegalArgumentException();
return sync.tryAcquireSharedNanos(permits, unit.toNanos(timout));
}
6. Semaphore permit 釋放方法
/**
* 釋放 permit
*/
public void release(){
sync.releaseShared(1);
}
/**
* 釋放 permit
*/
public void release(int permits){
if(permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
7. Semaphore 工具類方法
/**
* 返回可用的 permit
*/
public int availablePermits(){
return sync.getPermits();
}
/**
* 消耗光 permit
*/
public int drainPermits(){
return sync.drainPermits();
}
/**
* 減少 reduction 個permit
*/
protected void reducePermits(int reduction){
if(reduction < 0) throw new IllegalArgumentException();
sync.reducePermits(reduction);
}
/**
* 判斷是否是公平版本
*/
public boolean isFair(){
return sync instanceof FairSync;
}
/**
* 返回 AQS 中 Sync Queue 里面的等待線程
*/
public final boolean hasQueuedThreads(){
return sync.hasQueuedThreads();
}
/**
* 返回 AQS 中 Sync Queue 里面的等待線程長度
*/
public final int getQueueLength(){
return sync.getQueueLength();
}
/**
* 返回 AQS 中 Sync Queue 里面的等待線程
*/
protected Collection<Thread> getQueueThreads(){
return sync.getQueuedThreads();
}
8. 總結
Semaphore 通過 AQS中的 state 來進行控制 permit 的獲取控制, 其實它就是一個限制數量的 ReadLock; 但要真正理解 Semaphore, 還需要理解 AbstractQueuedSynchronizer
