java多线程Semaphore使用实例，细化粒度控制并发数量

1、Semaphore：线程协同类，用来控制线程并发数量，并且可以更加细粒度的进行控制，因为真正被控制最大并发的代码放到了acquire和release之间。

2、主要方法：

Semaphore semaphore = new Semaphore(int count);

信号量Semaphore的初始化方法，初始值 count 表示当前的信号量，即当前所允许并发访问的线程数。

semaphore.acquire();

表示获得一个许可，若信号量中的许可数已为0，则这个函数会出现等待的状况；
若已获取许可，则这个信号量的许可数为减一；

semaphore.release();

表示释放一个许可，若之前信号量的许可数已为0，那么当调用semaphore.release()
函数时，则此时的信号量中的许可数就会变为1；简而言之，就是将这个信号量中的许可数在原来的基础上
增加一个，而无论信号量之前的初始值是什么；

semaphore.availablePermits();

表示信号量semaphore此刻所拥有的许可数的个数

3、适用场景：

5个人同时去银行办理业务，但银行只有2个业务员，最开始，2个人同时办理，然后，任何一个业务办理完毕，马上办理下一个。

4、代码示例：

package com.test.thread.semaphore;

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

/** 
 * @author  javaloveiphone
 * @date 创建时间：2017年2月7日 上午10:38:53 
 * @Description: Semaphore信号量控制线程并发使用示例
 */
public class SemaphoreTest {

    public static void main(String[] args) throws InterruptedException {
        //创建线程池
        int count = 5;
        ExecutorService threadPool = Executors.newFixedThreadPool(count);

        //控制信号量，即线程并发数量为2
        Semaphore bankers = new Semaphore(2);
        //当前客户编号
        int consumer = 0;
        System.out.println("空闲业务员有："+bankers.availablePermits()+" 位");
        //客户数量
        for(int i=1;i<=count;i++){
            consumer = i;
            Bank bank = new Bank(bankers,consumer);
            threadPool.execute(bank);
        }
        Thread.sleep(1000);
        //关闭线程池
        threadPool.shutdown();
        System.out.println("空闲业务员有："+bankers.availablePermits()+" 位");
    }

}

class Bank implements Runnable{

    //银行业务员们
    private Semaphore bankers;
    //当前客户
    private int consumer;

    public Bank(Semaphore bankers,int consumer){
        this.bankers = bankers;
        this.consumer = consumer;
    }

    @Override
    public void run() {
        //客户拿号阶段，并不控制并发数量
        System.out.println("======客户进入银行先拿号，号码："+consumer+"，请等待叫号=========");
        try {
            //客户办理业务阶段，限制最多只能有2位客户同时办理业务
            //以上两条注释，可以发现更细粒度的控制线程并发个数

            //业务员开始服务，被占用
            bankers.acquire();

            System.out.println("客户："+consumer+" 开始办理业务，start");
            System.out.println("还剩业务员："+bankers.availablePermits()+" 位");
            Thread.sleep(100);
            System.out.println("客户："+consumer+" 办理业务完毕，end");

            //业务办理结束之后，业务员释放，准备为下一个客户服务
            bankers.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

可能的结果，打印情况如下：

空闲业务员有：2 位
======客户进入银行先拿号，号码：1，请等待叫号=========
客户：1 开始办理业务，start
还剩业务员：1 位
======客户进入银行先拿号，号码：3，请等待叫号=========
客户：3 开始办理业务，start
还剩业务员：0 位
======客户进入银行先拿号，号码：2，请等待叫号=========
======客户进入银行先拿号，号码：4，请等待叫号=========
======客户进入银行先拿号，号码：5，请等待叫号=========
客户：1 办理业务完毕，end
客户：3 办理业务完毕，end
客户：2 开始办理业务，start
客户：4 开始办理业务，start
还剩业务员：0 位
还剩业务员：0 位
客户：2 办理业务完毕，end
客户：4 办理业务完毕，end
客户：5 开始办理业务，start
还剩业务员：1 位
客户：5 办理业务完毕，end
空闲业务员有：2 位