聊聊Java里的Semaphore、CountDownLatch以及CyclicBarrier

Semaphore

Semaphore被翻译成信号量，他是并发编程领域得一大利器。信号量模型比较简单，可以概况为：一个计数器，一个等待队列，三个方法。其中这三个方法分别是：init()、down()和up()。我们就是通过这三个方法来操作计数器和等待队列，从而实现对线程的并发控制。

init():设置计数器的初始值。
down():计数器的值减 1;如果此时计数器的值小于 0，则当前线程将被阻塞，否则当前线程可以继续执行。
up():计数器的值加 1;如果此时计数器的值小于或者等于 0，则唤醒等待队列中的一个线程，并将其从等待队列中移除。

几乎每个高级编程语言都有对信号量模型的实现。在Java SDK里面，信号量模型是由 java.util.concurrent.Semaphore 实现的，Semaphore 这个类能够保证这三个方法都是原子操作，down() 和 up() 对应的则是 acquire() 和 release()。

acquire()和release()方法其实可以理解为jdk里的java.util.concurrent.locks.ReentrantLock类方法的lock()和unlock()，持有锁和释放锁的过程。不同的是lock只能实现对一个线程的控制，而Semaphore可以允许多个线程访问一个临界区。

下面是使用Semaphore控制线程的例子：


public class SemaphoreTest {

    private static int count;
    //初始化信号量为 1
    private static final Semaphore semaphore = new Semaphore(1); //相当于信号量模型的init()方法

    public static void addOne() throws InterruptedException {
        //使用信号量保证互斥，只有一个线程进入
        semaphore.acquire(); //相对于信号量模型的down()方法
        try {
            count++;
        } finally {
            semaphore.release();
        }
    }

    public static int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        //模拟100个线程同时访问
        CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                try {
                    addOne();
                    countDownLatch.await();
                    System.out.println(count);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        countDownLatch.countDown();
        TimeUnit.SECONDS.sleep(5);
        int count = getCount();
        System.out.println(count);
    }
}

这里的addOne()方法每次只允许1个线程访问，当然你如果想要N个线程同时访问只需要在构造的时候new Semaphore(N)填入N的值即可。
里面逻辑很简单，每个线程进来就会执行semaphore.acquire()方法将计数器减1，当计数器的值小于0的时候就会阻塞，大于等于0的时候就会往下执行。当执行到semaphore.release()的时候就会将计数器加1，当计数器大于等于0的时候其他线程就会被唤醒继续执行。

CountDownLatch

CountDownLatch和Semaphore一样都是在java1.5版本引入的，都是为了解决多线程并发问题，不同的是Semaphore是为了解决多个线程同时访问资源，而CountDownLatch为了协调多个线程的执行。
打个比方，有A和B两个线程，主线程需要等A和B两个线程都执行完之后才可以做后续的业务，这个时候就可以就可以使用CountDownLatch。

CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，主线程就可以继续工作了。


public class CountDownLatchTest {


    public static void main(String[] args) throws Exception{

        /*创建CountDownLatch实例,计数器的值初始化为3*/
        final CountDownLatch downLatch = new CountDownLatch(3);

        /*创建三个线程,每个线程等待1s,表示执行比较耗时的任务*/
        for(int i = 0;i < 3;i++){
            final int num = i;
            new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(1000);

                    }catch (InterruptedException e){
                        e.printStackTrace();

                    }
                    System.out.println(String.format("thread %d has finished",num));
                    /*任务完成后调用CountDownLatch的countDown()方法*/
                    downLatch.countDown();
                }
            }).start();
        }

        /*主线程调用await()方法,等到其他三个线程执行完后才继续执行*/
        downLatch.await();

        System.out.print("all threads have finished,main thread will continue run");
    }
}

以上代码设置了CountDownLatch计数器初始化值为3，主线程会阻塞在downLatch.await()这一行，直到3个线程都执行完downLatch.countDown()方法后主线程才会继续执行。

CyclicBarrier

CyclicBarrier和CountDownLatch类似都可以实现线程同步，不同的是CountDownLatch是一次性的，计数器到0就没办法重置了。CyclicBarrier设置的初始值会在所有线程调用完await()方法后自动重置成之前的值，并且CyclicBarrier还有一个回调线程，每次初始值置为0后就会调用回调线程执行。


    public static void main(String[] args) {
        int i = 3;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {
            @Override
            public void run() {
                System.out.println("所有线程等待完成");
            }
        });
        while (i > 0) {
            i--;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep((new Random().nextInt(5)));
                        System.out.println(Thread.currentThread().getName() + "线程准备就绪.." +"有"+ cyclicBarrier.getNumberWaiting() + "个线程已经开始等待");
                        cyclicBarrier.await();
                        System.out.println(Thread.currentThread().getName() + "线程执行完成..");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

        int j = 3;
        while (j > 0) {
            j--;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep((new Random().nextInt(5)));
                        System.out.println(Thread.currentThread().getName() + "线程准备就绪.." +"有"+ cyclicBarrier.getNumberWaiting() + "个线程已经开始等待");
                        cyclicBarrier.await();
                        System.out.println(Thread.currentThread().getName() + "线程执行完成..");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

执行结果

Thread-0线程准备就绪..有0个线程已经开始等待
Thread-2线程准备就绪..有1个线程已经开始等待
Thread-5线程准备就绪..有1个线程已经开始等待
所有线程等待完成
Thread-5线程执行完成..
Thread-0线程执行完成..
Thread-2线程执行完成..
Thread-1线程准备就绪..有0个线程已经开始等待
Thread-4线程准备就绪..有1个线程已经开始等待
Thread-3线程准备就绪..有2个线程已经开始等待
所有线程等待完成
Thread-3线程执行完成..
Thread-1线程执行完成..
Thread-4线程执行完成..

总结

Semaphore,CountDownLatch,CyclicBarrier底层都是通过AQS(AbstractQueuedSynchronizer)来实现并发操作的。
Semaphore信号量模型是解决并发编程领域的互斥问题，即同时只能有规定个数的线程访问共享资源。CountDownLatch和CyclicBarrier是解决同步问题，即线程之间如何通信、协作。

说细点CountDownLatch 主要用来解决一个线程等待多个线程的场景，可以类比旅游团团长要等待所有的游客到齐才能去下一个景点；而CyclicBarrier 是一组线程之间互相等待，更像是几个驴友之间不离不弃。除此之外CountDownLatch 的计数器是不能循环利用的，也就是说一旦计数器减到 0，再有线程调用await()，该线程会直接通过。但CyclicBarrier 的计数器是可以循环利用的，而且具备自动重置的功能，一旦计数器减到 0 会自动重置到你设置的初始值。除此之外，CyclicBarrier 还可以设置回调函数，可以说是功能丰富。