CyclicBarrier、CountDownLatch、Semaphore对比

CountDownLantch

称作线程计数器。

当某个线程需要等待其他 n 个线程执行完毕后才能执行，就可以使用CountDownLantch。

public static void main(String[] args) throws InterruptedException {
    int num = 2;
    final CountDownLatch latch = new CountDownLatch(num);
    for (int i = 0; i < num; i++) {
        new Thread(() -> {
            System.out.println("线程：" + Thread.currentThread().getName() + " 正在执行");
            try {
                Thread.sleep(1000);//模拟处理数据
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程：" + Thread.currentThread().getName() + " 执行完毕");
            latch.countDown();
        }).start();
    }
    System.out.println("等待两个其他线程执行完成");
    latch.await();//等待
    System.out.println("两个其他线程执行完毕");
    System.out.println("主线程继续执行");
}

CyclicBarrier

循环栅栏。

它可以实现让一组线程等待至某个状态之后再全部同时执行。当所有等待线程都被释放以后，CyclicBarrier 可以被重用。

我们暂且把这个状态就叫做barrier，当调用 await()方法之后，线程就处于 barrier 状态了。其实就像是“被栅栏挡住了”，暂时无法继续执行。

CyclicBarrier 中最重要的方法就是 await 方法，它有 2 个重载版本：

1. public int await()： 用来挂起当前线程，直至所有线程都到达 barrier 状态再同时执行后续任务。
2. public int await(long timeout, TimeUnit unit)： 让这些线程等待至一定的时间，如果还有线程没有到达 barrier 状态就直接让到达 barrier 的线程执行后续任务。

public static void main(String[] args) {
    int num = 3;
    final CyclicBarrier barrier = new CyclicBarrier(num);

    for(int i = 0; i < num; i++) {
        new Thread(() -> {
            try {
                Thread.sleep(1000); //模拟处理数据
                System.out.println("线程：" + Thread.currentThread().getName() + " 执行完毕");
                barrier.await(); //进入barrier状态 等待其他线程到达barrier
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("所有线程执行完成");
        }).start();
    }
}

Semaphore

信号量。

可以控制同时访问的线程个数，通过acquire() 获取一个许可，如果没有就等待，而release() 释放一个许可。

acquire和release方法还可以传入一个整形参数，由于指定申请/释放许可的数量。

另外tryAcquire 方法为尝试获取许可，若获取到则返回true，否则返回false，立即返回，不会等待。

public static void main(String[] args) {
    int num = 3;
    final Semaphore semaphore = new Semaphore(num);
    for (int i = 0; i < 5; i++) { //5个线程竞争3各临界资源
        new Thread(() -> {
            try {
                semaphore.acquire(); //获取许可
                System.out.println(Thread.currentThread().getName() + " 获取到了许可");
                Thread.sleep(1000); //模拟处理
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 执行完毕");
            semaphore.release(); //释放许可
        }).start();
    }
}

运行一次输出如下（结果是不确定的，但最多同时3个线程获取了许可）：

Thread-0 获取到了许可
Thread-2 获取到了许可
Thread-1 获取到了许可
Thread-2 执行完毕
Thread-1 执行完毕
Thread-3 获取到了许可
Thread-0 执行完毕
Thread-4 获取到了许可
Thread-4 执行完毕
Thread-3 执行完毕

对比

CountDownLatch 和 CyclicBarrier 都能够实现线程之间的等待，只不过它们侧重点不同；

CountDownLatch 一般用于某个线程 等待若干个其他线程执行完任务之后，它才执行；

而 CyclicBarrier 一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；

另外， CountDownLatch 是不能重用的，而 CyclicBarrier 是可以重用的。

Semaphore 其实和锁有点类似，它一般用于控制对某组资源的访问权限。

我的更多文章尽在：我的个人博客