|
|
|
Semaphore为并发包中提供用于控制某资源同时可以被几个线程访问的类 实例代码： // 允许2个线程同时访问
final Semaphore semaphore = new Semaphore(2);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
executorService.execute(new Runnable() {
public void run() {
try {
semaphore.acquire();
// 这里可能是业务代码
System.out.println("线程:" + Thread.currentThread().getName() + "获得许可:" + index);
TimeUnit.SECONDS.sleep(1);
semaphore.release();
System.out.println("允许TASK个数：" + semaphore.availablePermits());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
executorService.shutdown();构造方法1： public Semaphore(int permits) {
sync = new NonfairSync(permits);
}permits 初始许可数，也就是最大访问线程数 构造方法2： public Semaphore(int permits, boolean fair) {
sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}permits 初始许可数，也就是最大访问线程数 fair 当设置为false时，线程获取许可的顺序是无序的，也就是说新线程可能会比等待的老线程会先获得许可;当设置为true时，信号量保证它们调用的顺序（即先进先出；FIFO） 主要方法： 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()：释放一个许可，别忘了在finally中使用，注意：多次调用该方法，会使信号量的许可数增加，达到动态扩展的效果，如：初始permits 为1， 调用了两次release，最大许可会改变为2 int availablePermits()：获取当前信号量可用的许可 JDK 非公平Semaphore实现： 1. 使用一个参数的构造创建Semaphore对象时，会创建一个NonfairSync对象实例，并将state值设为传入的值（permits ） public Semaphore(int permits) {
sync = new NonfairSync(permits);
}NonfairSync间接的继承了AbstractQueuedSynchronizer实现 final static class NonfairSync extends Sync {
private static final long serialVersionUID = -2694183684443567898L;
NonfairSync(int permits) {
super(permits);
}
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
}abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 1192457210091910933L;
Sync(int permits) {
setState(permits);
}AbstractQueuedSynchronizer 的setState方法 protected final void setState(int newState) {
state = newState;
}2. 调用tryAcquire方法时，实际是调用NonfairSync的nonfairTryAcquireShared方法，nonfairTryAcquireShared在父类Sync中实现， Semaphore# tryAcquire方法： public boolean tryAcquire() {
return sync.nonfairTryAcquireShared(1) >= 0;
}Sync的nonfairTryAcquireShared方法 final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}nonfairTryAcquireShared方法通过获取当前的state，以此state减去需要获取信号量的个数，作为剩余个数，如果结果小于0，返回此剩余的个数；如果结果大于等于0，则基于CAS将state的值设置为剩余个数，当前步骤用到了for循环，所以只有在结果小于0或设置state值成功的情况下才会退出。 如果返回的剩余许可个数大于0，tryAcquire方法则返回true；其余返回false。 AbstractQueuedSynchronizer的compareAndSetState方法， protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}3. release方法，释放一个许可 public void release() {
sync.releaseShared(1);
}AbstractQueuedSynchronizer的releaseShared方法， public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}release方法间接的调用了Sync的tryReleaseShared方法，该方法基于Cas 将state的值设置为state+1，一直循环确保CAS操作成功，成功后返回true。 protected final boolean tryReleaseShared(int releases) {
for (;;) {
int p = getState();
if (compareAndSetState(p, p + releases))
return true;
}
}根据上面分析，可以看得出，Semaphore采用了CAS来实现，尽量避免锁的使用，提高了性能。 Reference： http://blog.csdn.net/java2000_wl/article/details/23556859 转载请并标注: “本文转载自 linkedkeeper.com ” ©著作权归作者所有 |
