java 并发工具包 -信号量 Semaphore

简介：

Semaphore，信号量，用于控制同时访问的线程数据，如果达到阀值，那么只能等到某线程释放才能被其他线程继续访问。

源码解析:

public class Semaphore implements java.io.Serializable {
private static final long serialVersionUID = -3222578661600680210L;
//和CountDownLatch 一样，定义内部类Sync继承AbstractQueuedSynchronizer ，相对而言，对比CountDownLatch 重写父类方法多一些
private final Sync sync;
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 1192457210091910933L;
//初始化计数器
Sync(int permits) {
setState(permits);
}
//获取计数器
final int getPermits() {
return getState();
}
//非公平的获取 计数器-acquires 即消耗了acquires个位置
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
//如果remining<0了的话 就不执行compareAndSetState了 并且返回remining
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
//计数器+releases 即增加了releases 个位置 并释放了头部线程
protected final boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();
int next = current + releases;
//releases不能为负数
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
//计数器-reductions 即消耗了reductions个位置
final void reducePermits(int reductions) {
for (;;) {
int current = getState();
int next = current - reductions;
//reductions不能为负数
if (next > current) // underflow
throw new Error("Permit count underflow");
if (compareAndSetState(current, next))
return;
}
}
//返回当前计数器值 并设置为0  即全部占有
final int drainPermits() {
for (;;) {
int current = getState();
if (current == 0 || compareAndSetState(current, 0))
return current;
}
}
}

/**
*非公平模式
*/
static final class NonfairSync extends Sync {
private static final long serialVersionUID = -2694183684443567898L;

NonfairSync(int permits) {
super(permits);
}

protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
}

/**
* 公平模式
*/
static final class FairSync extends Sync {
private static final long serialVersionUID = 2014338818796000944L;

FairSync(int permits) {
super(permits);
}
//和非公平模式不一样的地方
protected int tryAcquireShared(int acquires) {
for (;;) {
// 如果当前线程不在头部节点并且头结点和尾节点不相等 返回-1
if (hasQueuedPredecessors())
return -1;
//同公平模式
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}

//初始化默认使用的非公平模式
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}

//指定模式
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

public void acquire() throws InterruptedException {
//可打断  无位置则阻塞
sync.acquireSharedInterruptibly(1);
}

//不可打断 无位置则阻塞
public void acquireUninterruptibly() {
sync.acquireShared(1);
}

//尝试获取 直接调用的就是非公平模式  不阻塞
public boolean tryAcquire() {
return sync.nonfairTryAcquireShared(1) >= 0;
}

//尝试获取 阻塞直至超时返回
public boolean tryAcquire(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

//释放 并释放一个位置
public void release() {
sync.releaseShared(1);
}

//可打断 获取permits位置  一直阻塞 直到获取成功
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}

//不可打断 获取permits位置   一直阻塞 直到获取成功
public void acquireUninterruptibly(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireShared(permits);
}

//尝试获取permits位置 不阻塞
public boolean tryAcquire(int permits) {
if (permits < 0) throw new IllegalArgumentException();
return sync.nonfairTryAcquireShared(permits) >= 0;
}

//尝试获取permits位置  阻塞直至时间过期
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
}

//释放permits位置 且唤醒线程
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}

//将剩余的位置全部占用
public int drainPermits() {
return sync.drainPermits();
}

//释放reduction位置 但不去唤醒
protected void reducePermits(int reduction) {
if (reduction < 0) throw new IllegalArgumentException();
sync.reducePermits(reduction);
}

//释放公平模式
public boolean isFair() {
return sync instanceof FairSync;
}

//是否拥有等待的线程  其实就是去判断头部和尾部是否不相等
public final boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}

//获取等待的线程长度
public final int getQueueLength() {
return sync.getQueueLength();
}

//返回所有线程
protected Collection<Thread> getQueuedThreads() {
return sync.getQueuedThreads();
}

public String toString() {
return super.toString() + "[Permits = " + sync.getPermits() + "]";
}
}

简单例子 ：

public class SemaphoreTest {
public static void main(String[] args) throws InterruptedException {
Semaphore semaphore = new Semaphore(5);
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {

@Override
public void run() {
try {
semaphore.acquire();
System.out.println("线程" + Thread.currentThread().getName() + "执行中");
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
semaphore.release();
}
System.out.println("线程" + Thread.currentThread().getName() + "执行完毕");

}
}, "thread" + i).start();
}

}
}

总结：

“公平信号量”和”非公平信号量”的释放信号量的机制是一样的！不同的是它们获取信号量的机制：线程在尝试获取信号量许可时，对于公平信号量而言，如果当前线程不在队列的头部，则排队等候；而对于非公平信号量而言，无论当前线程是不是在队列的头部，它都会直接获取信号量。

Semaphore通过acquire和release方法来进行获取和释放，可以不停的进行操作，用于控制线程数。

Semaphore也用到了AbstractQueuedSynchronizer，那么 下一篇就来解析下著名的AQS