Java多线程:Semaphore

　　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）
　　主要方法：托福答案 www.yztrans.com
　　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.托福答案 www.qcwy123.com
　　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来实现，尽量避免锁的使用，提高了性能。