Java并发编程——Semaphore （信号量）和CountDownLatch

一、Semaphore （信号量）

        说简单点，Semaphore维护了一个许可集合，在创建Semaphore的时候，设置上许可数，每条线程在只有在获得一个许可的时候才可以继续往下执行逻辑（申请一个许可，则Semaphore的许可池中减少一个许可），没有获得许可的线程会进入阻塞状态。

举个栗子：

public static void main(String[] args) {
        //创建一个Semaphore 有5条许可
        final Semaphore semaphore = new Semaphore(5);
        for (int i = 0; i < 10; i++) {
            final int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //申请一个许可  许可池-1   若许可池为0则申请许可失败，阻塞线程
                        semaphore.acquire();
                        System.out.print(finalI);
                        //模仿耗时操作
                        Thread.sleep(1000);
                        //释放一个许可  许可池+1
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

然后看log的打印：

12-19 11:06:52.720 13842-13978/lbx.myapplication E/lbxlog: 0
12-19 11:06:52.720 13842-13981/lbx.myapplication E/lbxlog: 3
12-19 11:06:52.720 13842-13979/lbx.myapplication E/lbxlog: 1
12-19 11:06:52.720 13842-13980/lbx.myapplication E/lbxlog: 2
12-19 11:06:52.720 13842-13982/lbx.myapplication E/lbxlog: 4
//这里注意一下  仔细对比时间
12-19 11:06:53.720 13842-13983/lbx.myapplication E/lbxlog: 5
12-19 11:06:53.720 13842-13985/lbx.myapplication E/lbxlog: 7
12-19 11:06:53.720 13842-13987/lbx.myapplication E/lbxlog: 9
12-19 11:06:53.720 13842-13986/lbx.myapplication E/lbxlog: 8
12-19 11:06:53.720 13842-13984/lbx.myapplication E/lbxlog: 6

       看了上面的log，发现前五个是52秒左右打印出来的，而后五个是53秒左右打印出来的，因为许可池里只有5个许可，前五条线程把5个许可占用了，后五条线程需要等到有许可后才会继续执行逻辑。

接下来介绍几个常用的方法：

//释放1个许可
semaphore.release();
//使acquire()后正在等待的线程不可被终止
semaphore.acquireUninterruptibly();
//获取当前可用的许可数量，并把可用的许可数置0
semaphore.drainPermits();
//是否有正在等待的线程
semaphore.hasQueuedThreads();
//获取正在等待的线程数量
semaphore.getQueueLength();
//获取当前可用的许可数量
semaphore.availablePermits();

二、信号量的另一种形式：非公平信号量

        非公平信号量，先运行的线程不一定可以申请到许可，后运行的线程不一定不可以申请到许可。

//创建5个公平信号量
Semaphore semaphore = new Semaphore(5,true);
//尝试获得许可，并返回获取结果   if(acquireSuc)...else...
boolean acquireSuc = semaphore.tryAcquire();
boolean acquireSuc = semaphore.tryAcquire(2);
//在3秒内尝试获得1个许可，并返回获取结果
boolean acquireSuc = semaphore.tryAcquire(3, TimeUnit.SECONDS);
//在3秒内尝试获得2个许可，并返回获取结果
boolean acquireSuc = semaphore.tryAcquire(2, 3, TimeUnit.SECONDS);

三、CountDownLatch的应用

    这个东西和信号量正相反，CountDownLatch的内部维护着一个计数器，同时只有一个线程才可对计数器进行操作，当计数器为0的时候，释放所有阻塞的线程。

举个栗子：

public static void main(String[] args) {
        //4条线程
        int threadCount = 4;
        //创建一个拥有5个计数器的countDownLatch
        final CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0; i < threadCount; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //使计数器-1
                    countDownLatch.countDown();
                    System.out.println("计数器还剩" + countDownLatch.getCount());
                }
            }).start();
        }

        try {
            //在这里阻塞  只有计数器为0的时候这行代码才会释放
             countDownLatch.await();
            } catch (InterruptedException e) {
             e.printStackTrace();
            }

  System.out.println("执行完成啦！"); 
}

log：
 

12-19 11:52:25.350 22929-23074/lbx.myapplication I/System.out: 计数器还剩4
12-19 11:52:25.350 22929-23073/lbx.myapplication I/System.out: 计数器还剩3
12-19 11:52:25.350 22929-23075/lbx.myapplication I/System.out: 计数器还剩2
12-19 11:52:25.350 22929-23076/lbx.myapplication I/System.out: 计数器还剩1

因为计数器没有到0，所以“执行完成”这句话没有打印，将线程改成5条：

//5线程
        int threadCount = 5;

log：

12-19 11:58:46.570 30347-30471/lbx.myapplication I/System.out: 计数器还剩4
12-19 11:58:46.570 30347-30473/lbx.myapplication I/System.out: 计数器还剩3
12-19 11:58:46.570 30347-30472/lbx.myapplication I/System.out: 计数器还剩2
12-19 11:58:46.570 30347-30474/lbx.myapplication I/System.out: 计数器还剩1
12-19 11:58:46.570 30347-30475/lbx.myapplication I/System.out: 计数器还剩0
12-19 11:58:46.570 30347-30347/lbx.myapplication I/System.out: 执行完成啦！

这时候完整的流程就执行完了。常用方法：

//使线程进入阻塞状态，计数为0的时候释放线程
countDownLatch.await();
//使线程进入阻塞状态，计数为0的时候释放线程或者阻塞到3秒的时候自动释放线程
countDownLatch.await(3, TimeUnit.SECONDS);
//使计数减1
countDownLatch.countDown();
//获取当前的计数
countDownLatch.getCount();