线程：Semaphore实现信号灯

　　Semaphore是一个计数的信号量，可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，例如实现一个文件允许的线程访问数。打个通俗的比喻，Semaphore实现的功能类似厕所有4个坑，假如有10个人上厕所，那么同时有多少个人去上厕所呢？同时只能有4个人能够占用，当4个人中的任何一个人让开后，其中在等待的另外6个人又有一个可以占用了。

 package ch03;

 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Semaphore;

 public class SemaphoreTest {

     public static void main(String[] args) {
         ExecutorService threadPool = Executors.newCachedThreadPool();
         //获取三个许可的信号灯
         final Semaphore sp = new Semaphore(5);
         for(int i=1; i<=10; i++){
             final int index = i;
             Runnable runable = new Runnable() {

                 @Override
                 public void run() {
                     try {
                         //获取一个信号灯
                         sp.acquire();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     System.out.println("有一个"+Thread.currentThread().getName()+
                             "线程进来了，当前有"+(5-sp.availablePermits())+"线程正在并发...");

                     try {
                         Thread.sleep(index * 1000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     //释放信号灯
                     sp.release();
                     System.out.println("线程"+Thread.currentThread().getName()+"离开了，现在还有"+(5-sp.availablePermits())+"个线程!");
                 }
             };
             threadPool.execute(runable);
         }
         threadPool.shutdown();
     }

 }

至于，在等待的6个人中谁先进去，有两种方式：一种是看谁快，第二种是按排序，先来的先进去。可以通过Semaphore的构造函数指定：

如果使用排序的方式，可以将fair设为true.

除此之外，单个信号量的Semaphore对象还可以实现互斥锁的功能，只有一个灯，A线程获得，B线程就等着。传统的互斥锁，同一个线程的锁只能由自己释放，但Semaphore对象的互斥锁可以是由一个线程获得锁，再由另外一个线程释放锁，可以应用于死锁恢复的场合。比如一个人进厕所后，晕在里面了，这样的话可以去找管理员拿备用钥匙，打开门将人挪出来，这样就避免后面的人一直堵在这里。