当我们创建一个可扩展大小的线程池，并且需要在线程池内同时让有限数目的线程并发运行时，就需要用到Semaphore（信号灯机制），Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目，它是一个计数信号量，从概念上讲，信号量维护了一个许可集合，如有必要，在许可可用前会阻塞每一个acquire()，然后再获取该许可，每个release() 添加一个许可，从而可能释放一个正在阻塞的获取者。       
        在线程池内创建线程并运行时，每个线程必须从信号量获取许可，从而保证可以使用该项。该线程结束后，线程返回到池中并将许可返回到该信号量，从而允许其他线程获取该项。注意，调用acquire() 时无法保持同步锁定，因为这会阻止线程返回到池中。信号量封装所需的同步，以限制对池的访问，这同维持该池本身一致性所需的同步是分开的。下面通过一个例子加以说明：
[java]
public class SemaphoreTest { 
    public static void main(String[] args) { 
        ExecutorService service = Executors.newCachedThreadPool(); 
        final  Semaphore sp = new Semaphore(3); 
        for(int i=0;i<5;i++){ 
            Runnable runnable = new Runnable(){ 
                    public void run(){ 
                    try { 
                        sp.acquire(); 
                    } catch (InterruptedException e1) { 
                        e1.printStackTrace(); 
                    } 
                    System.out.println("线程" + Thread.currentThread().getName() +  
                            "进入，当前已有" + (3-sp.availablePermits()) + "个并发"); 
                    try { 
                        Thread.sleep((long)(Math.random()*10000)); 
                    } catch (InterruptedException e) { 
                        e.printStackTrace(); 
                    } 
                    System.out.println("线程" + Thread.currentThread().getName() +  
                            "即将离开");                     
                    sp.release(); 
                    //下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元 
                    System.out.println("线程" + Thread.currentThread().getName() +  
                            "已离开，当前已有" + (3-sp.availablePermits()) + "个并发"); 
                } 
            }; 
            service.execute(runnable);           
        } 
    } 
} 

       该例子定义了一个newCachedThreadPool，在该Pool中利用for循环同时创建5个线程，现在通过Semaphore，创建一个只允许在线程池中有3个线程并发运行，sp.acquire()表示某个线程获得了一个信号灯，开始运行，在运行结束时，通过sp.release()还回这个信号灯，以便剩下的线程获得信号灯运行，sp.availablePermits()指的是当前信号灯库中有多少个可以被使用，由于例子中定义有3个信号灯，所以3-sp.availablePermits()就代表了当前有多少个线程在并发运行，上例运行结果如下：
[java] 
线程pool-1-thread-1进入，当前已有2个并发 
线程pool-1-thread-2进入，当前已有2个并发 
线程pool-1-thread-3进入，当前已有3个并发 
线程pool-1-thread-1即将离开 
线程pool-1-thread-1已离开，当前已有2个并发 
线程pool-1-thread-4进入，当前已有3个并发 
线程pool-1-thread-3即将离开 
线程pool-1-thread-3已离开，当前已有2个并发 
线程pool-1-thread-5进入，当前已有3个并发 
线程pool-1-thread-2即将离开 
线程pool-1-thread-2已离开，当前已有2个并发 
线程pool-1-thread-4即将离开 
线程pool-1-thread-4已离开，当前已有1个并发 
线程pool-1-thread-5即将离开 
线程pool-1-thread-5已离开，当前已有0个并发 

    
Semaphore作为互斥锁使用：
       当信号量初始化为 1，使得它在使用时最多只有一个可用的许可，从而可用作一个相互排斥的锁。这通常也称为二进制信号量，因为它只能有两种状态：一个可用的许可，或零个可用的许可。按此方式使用时，与传统互斥锁最大不同就是在释放的时候并不是必须要拥有锁的对象释放，也可以由其他的对象释放，因为信号量没有所有权的概念。在某些专门的上下文（如死锁恢复）中这会很有用。

Semaphore的构造方法有两种：
第一种：
[java] 
Semaphore(int permits) //用给定的许可数和非公平的公平设置创建一个 Semaphore。 
       第一种构造方法创建的信号灯，现在在获取的时候是随机的，没有一定的顺序，例如上例中，在前三个线程中的一个运行完毕以后，释放一个信号灯，剩下的两个线程就会随机的一个线程得到这个信号灯而运行。
第二种：
[java]
Semaphore(int permits, boolean fair) //用给定的许可数和给定的公平设置创建一个 Semaphore 

      第二种构造方法可选地接受一个公平 参数。当设置为 false 时，此类不对线程获取许可的顺序做任何保证。特别地，闯入 是允许的，也就是说可以在已经等待的线程前为调用acquire() 的线程分配一个许可，从逻辑上说，就是新线程将自己置于等待线程队列的头部。当公平设置为 true 时，信号量保证对于任何调用acquire() 方法的线程而言，都按照处理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。注意，FIFO 排序必然应用到这些方法内的指定内部执行点。所以，可能某个线程先于另一个线程调用了acquire()，但是却在该线程之后到达排序点，并且从方法返回时也类似。还要注意，非同步的tryAcquire() 方法不使用公平设置，而是使用任意可用的许可。
      通常，应该将用于控制资源访问的信号量初始化为公平的，以确保所有线程都可访问资源。为其他的种类的同步控制使用信号量时，非公平排序的吞吐量优势通常要比公平考虑更为重要。