CountDownLatch

CountDownLatch是计数器，作用是阻塞主线程，直到若干子线程都执行完毕，再继续执行主线程，比如阻塞餐厅的服务员（不让他开门），等到所有顾客都赶到了（顾客是子线程，赶路是线程的操作），服务员才开门。

CyclicBarrier

CyclicBarrier是循环栅栏，作用是：一个或多个线程都执行完一部分操作后，再一起执行另一部分操作，比如所有顾客都赶到餐厅后，服务员才开门，然后顾客才可以一起吃饭；
CyclicBarrier也可以达到CountDownLatch的效果；
CyclicBarrier可以循环利用，CountDownLatch不行。

Semaphore

Semaphore意为信号量，用于限制访问某个资源的线程数，比如限制同一时间餐厅只能容纳三个顾客。

CountDownLatch使用示例

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.concurrent.*;

/**
 * CountDownLatch示例类
 *
 * CountDownLatch作用：
 * CountDownLatch是一个计数器，通过构造函数传入count，表示有count个子线程
 * 用await方法阻塞主线程
 * 每个子线程执行完毕后，通过countDown函数把计数器-1，countDown为0表示子线程执行完毕，主线程继续执行
 *
 * ThreadPoolExecutor的awaitTermination()能达到同样的效果
 *
 */
public class CountDownLatchDemo {
    public static void main(String[] args) throws Exception{
        System.out.println("主线程开始执行");
        int limit = 5;
        CountDownLatch countDownLatch = new CountDownLatch(limit);

        ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("CountDownLatchDemo-pool-%d").build();
        ThreadPoolExecutor pool = new ThreadPoolExecutor(limit, limit, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(1024), factory, new ThreadPoolExecutor.AbortPolicy());

        for (int i = 0; i < limit; i++) {
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (countDownLatch) {
                        countDownLatch.countDown();
                        System.out.println("子线程开始执行，name: " + Thread.currentThread().getName() + ", countDownLatch.getCount(): " + countDownLatch.getCount());
                    }
                }
            });
        }

        pool.shutdown();
        countDownLatch.await();
        System.out.println("子线程执行完毕，主线程继续执行");
    }
}

输出结果

主线程开始执行
子线程开始执行，name: CountDownLatchDemo-pool-2, countDownLatch.getCount(): 4
子线程开始执行，name: CountDownLatchDemo-pool-1, countDownLatch.getCount(): 3
子线程开始执行，name: CountDownLatchDemo-pool-0, countDownLatch.getCount(): 2
子线程开始执行，name: CountDownLatchDemo-pool-3, countDownLatch.getCount(): 1
子线程开始执行，name: CountDownLatchDemo-pool-4, countDownLatch.getCount(): 0
子线程执行完毕，主线程继续执行

CyclicBarrier示例代码

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.concurrent.*;

/**
 * CyclicBarrier示例类
 *
 * CyclicBarrier作用：
 * CyclicBarrier意为循环栅栏，栅栏相当于一个门，一开始栅栏关闭着，所有子线程先执行一部分操作，都到达栅栏后，栅栏才开启，然后所有子线程再一起执行下一部分操作。
 * 可以把CyclicBarrier比喻成餐厅的门，所有顾客都到了，餐厅才开门，然后顾客才可以吃饭。
 * 之所以叫循环栅栏，是因为CyclicBarrier的reset方法可以重置栅栏。
 *
 */
public class CyclicBarrierDemo {

    public static void main(String[] args) {
        int limit = 5;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                // 栅栏开启时，主线程的操作
                System.out.println("开启栅栏");
            }
        });

        ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("CyclicBarrierDemo-pool-%d").build();
        ThreadPoolExecutor pool = new ThreadPoolExecutor(limit, limit, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(1024), factory, new ThreadPoolExecutor.AbortPolicy());

        for (int i = 0; i < limit; i++) {
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 栅栏开启前子线程的操作
                        Thread.sleep(1000);
                        System.out.println("子线程" + Thread.currentThread().getName() + "开始等待");

                        // await方法会阻塞子线程至栅栏开启
                        cyclicBarrier.await();

                        // 栅栏开启后子线程的操作
                        System.out.println("子线程" + Thread.currentThread().getName() + "开始执行");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        pool.shutdown();
    }

}

输出结果

子线程CyclicBarrierDemo-pool-1开始等待
子线程CyclicBarrierDemo-pool-0开始等待
子线程CyclicBarrierDemo-pool-4开始等待
子线程CyclicBarrierDemo-pool-2开始等待
子线程CyclicBarrierDemo-pool-3开始等待
开启栅栏
子线程CyclicBarrierDemo-pool-3开始执行
子线程CyclicBarrierDemo-pool-1开始执行
子线程CyclicBarrierDemo-pool-2开始执行
子线程CyclicBarrierDemo-pool-4开始执行
子线程CyclicBarrierDemo-pool-0开始执行

Semaphore示例代码

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.concurrent.*;

/**
 * Semaphore示例类
 *
 * Semaphore作用：
 * Semaphore意为信号量，用于限制访问某个资源的线程数
 *
 */
public class SemaphoreDemo {

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        int threadCount = 10;
        ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("SemaphoreDemo-pool-%d").build();
        ThreadPoolExecutor pool = new ThreadPoolExecutor(threadCount, threadCount, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(1024), factory, new ThreadPoolExecutor.AbortPolicy());

        for (int i = 0; i < threadCount; i++) {
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 获取信号量
                        semaphore.acquire();
                        System.out.println("子线程" + Thread.currentThread().getName() + "开始执行");
                        Thread.sleep(1000);
                        System.out.println("子线程" + Thread.currentThread().getName() + "执行完毕");
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        // release方法放到finally，确保可以释放信号量
                        semaphore.release();
                    }
                }
            });
        }

        pool.shutdown();
    }
}

输出结果

子线程SemaphoreDemo-pool-0开始执行
子线程SemaphoreDemo-pool-1开始执行
子线程SemaphoreDemo-pool-2开始执行
子线程SemaphoreDemo-pool-0执行完毕
子线程SemaphoreDemo-pool-3开始执行
子线程SemaphoreDemo-pool-1执行完毕
子线程SemaphoreDemo-pool-2执行完毕
子线程SemaphoreDemo-pool-4开始执行
子线程SemaphoreDemo-pool-5开始执行
子线程SemaphoreDemo-pool-3执行完毕
子线程SemaphoreDemo-pool-4执行完毕
子线程SemaphoreDemo-pool-5执行完毕
子线程SemaphoreDemo-pool-7开始执行
子线程SemaphoreDemo-pool-6开始执行
子线程SemaphoreDemo-pool-8开始执行
子线程SemaphoreDemo-pool-8执行完毕
子线程SemaphoreDemo-pool-7执行完毕
子线程SemaphoreDemo-pool-6执行完毕
子线程SemaphoreDemo-pool-9开始执行
子线程SemaphoreDemo-pool-9执行完毕