java semaphore 原理_信号量Semaphore实现原理

Semaphore用于管理信号量，在并发编程中，可以控制返访问同步代码的线程数量。Semaphore在实例化时传入一个int值，也就是指明信号数量。主要方法有两个：acquire()和release()。acquire()用于请求信号，每调用一次，信号量便少一个。release()用于释放信号，调用一次信号量加一个。信号量用完以后，后续使用acquire()方法请求信号的线程便会加入阻塞队列挂起。本篇简单分析Semaphore的源码，说明其实现原理。

Semaphore对于信号量的控制是基于AQS(AbstractQueuedSynchronizer)来做的。Semaphore有一个内部类Sync继承了AQS。而且Semaphore中还有两个内部类FairSync和NonfairSync继承Sync，也就是说Semaphore有公平锁和非公平锁之分。以下是Semaphore中内部类的结构：

看一下Semaphore的两个构造函数：

public Semaphore(intpermits) {

sync= newNonfairSync(permits);

}public Semaphore(intpermits, boolean fair) {

sync= fair ? new FairSync(permits) : newNonfairSync(permits);

}

默认是非公平锁。两个构造方法都必须传int permits值。

这个int值在实例化内部类时，被设置为AQS中的state。

Sync(intpermits) {

setState(permits);

}

一、acquire()获取信号

内部类Sync调用AQS中的acquireSharedInterruptibly()方法

public final void acquireSharedInterruptibly(intarg)

throws InterruptedException {if(Thread.interrupted())throw newInterruptedException();if (tryAcquireShared(arg) < 0)

doAcquireSharedInterruptibly(arg);

}

调用tryAcquireShared()方法尝试获取信号。

如果没有可用信号，将当前线程加入等待队列并挂起

tryAcquireShared()方法被Semaphore的内部类NonfairSync和FairSync重写，实现有一些区别。

NonfairSync.tryAcquireShared()

final int nonfairTryAcquireShared(intacquires) {for(;;) {int available =getState();int remaining = available -acquires;if (remaining < 0 ||compareAndSetState(available, remaining))returnremaining;

}

}

可以看到，非公平锁对于信号的获取是直接使用CAS进行尝试的。

FairSync.tryAcquireShared()

protected int tryAcquireShared(intacquires) {for(;;) {if(hasQueuedPredecessors())return -1;int available =getState();int remaining = available -acquires;if (remaining < 0 ||compareAndSetState(available, remaining))returnremaining;

}

}

先调用hasQueuedPredecessors()方法，判断队列中是否有等待线程。如果有，直接返回-1，表示没有可用信号

队列中没有等待线程，再使用CAS尝试更新state，获取信号

再看看acquireSharedInterruptibly()方法中，如果没有可用信号加入队列的方法doAcquireSharedInterruptibly()

private void doAcquireSharedInterruptibly(intarg)

throws InterruptedException {

final Node node=addWaiter(Node.SHARED); // 1

boolean failed= true;try{for(;;) {

final Node p=node.predecessor();if (p ==head) { // 2int r =tryAcquireShared(arg);if (r >= 0) {

setHeadAndPropagate(node, r);

p.next= null; //help GC

failed = false;return;

}

}if (shouldParkAfterFailedAcquire(p, node) && // 3parkAndCheckInterrupt())throw newInterruptedException();

}

}finally{if(failed)

cancelAcquire(node);

}

}

封装一个Node节点，加入队列尾部

在无限循环中，如果当前节点是头节点，就尝试获取信号

不是头节点，在经过节点状态判断后，挂起当前线程

二、release()释放信号

public final boolean releaseShared(intarg) {if(tryReleaseShared(arg)) { // 1

doReleaseShared(); // 2return true;

}return false;

}

更新state加一

唤醒等待队列头节点线程

tryReleaseShared()方法在内部类Sync中被重写

protected final boolean tryReleaseShared(intreleases) {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;

}

}

这里也就是直接使用CAS算法，将state也就是可用信号，加1。

看看Semaphore具体的使用示例：

public static voidmain(String[] args) {

ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 10,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue(10));//信号总数为5

Semaphore semaphore = new Semaphore(5);//运行10个线程

for (int i = 0; i < 10; i++) {

threadPool.execute(newRunnable() {

@Overridepublic voidrun() {try{//获取信号

semaphore.acquire();

System.out.println(Thread.currentThread().getName() + "获得了信号量,时间为" +System.currentTimeMillis());//阻塞2秒，测试效果

Thread.sleep(2000);

System.out.println(Thread.currentThread().getName() + "释放了信号量,时间为" +System.currentTimeMillis());

}catch(InterruptedException e) {

e.printStackTrace();

}finally{//释放信号

semaphore.release();

}

}

});

}

threadPool.shutdown();

}

代码结果为：

pool-1-thread-2获得了信号量,时间为1550584196125

pool-1-thread-1获得了信号量,时间为1550584196125

pool-1-thread-3获得了信号量,时间为1550584196125

pool-1-thread-4获得了信号量,时间为1550584196126

pool-1-thread-5获得了信号量,时间为1550584196127

pool-1-thread-2释放了信号量,时间为1550584198126

pool-1-thread-3释放了信号量,时间为1550584198126

pool-1-thread-4释放了信号量,时间为1550584198126

pool-1-thread-6获得了信号量,时间为1550584198126

pool-1-thread-9获得了信号量,时间为1550584198126

pool-1-thread-8获得了信号量,时间为1550584198126

pool-1-thread-1释放了信号量,时间为1550584198126

pool-1-thread-10获得了信号量,时间为1550584198126

pool-1-thread-5释放了信号量,时间为1550584198127

pool-1-thread-7获得了信号量,时间为1550584198127

pool-1-thread-6释放了信号量,时间为1550584200126

pool-1-thread-8释放了信号量,时间为1550584200126

pool-1-thread-10释放了信号量,时间为1550584200126

pool-1-thread-9释放了信号量,时间为1550584200126

pool-1-thread-7释放了信号量,时间为1550584200127

可以看到，最多5个线程获得信号，其它线程必须等待获得信号的线程释放信号。