JUC并发包之CountDownLatch、CyclicBarrier和Semaphore（附测试代码）

使用CountDownLatch、CyclicBarrier和Semaphore这三个线程同步器类可以大大减少在Java并发编程中使用wait、norify、join等来实现线程同步的代码量并保证正确性。同时这三个类的使用也各有区别，接下来进行一一介绍。

 CountDownLatch

CountDownLatch经典场景是一个主线程等待多个子线程执行完毕再进行汇总的场景。他的内部维护一个计数器来控制线程同步（实际上是使用AQS来存放计数器的值）。

---

首先在初始化CountDownLatch时我们设置计数器的值，线程调用await方法后当前线程会被放入AQS的阻塞队列等待计数器的值为0再返回，当多个线程调用countdown方法时实际是原子性递减计数器。

import java.util.concurrent.*;

public class Main1 {
    public static CountDownLatch countDownLatch = new CountDownLatch(2);
    public static void main(String[] args)  {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程1正在执行");
                    Thread.sleep(2000);
                    System.out.println("线程1执行完毕");
                    countDownLatch.countDown();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程2正在执行");
                    Thread.sleep(2000);
                    System.out.println("线程2执行完毕");
                    countDownLatch.countDown();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("两个线程都已经执行完毕");
        executorService.shutdown();
    }
}

运行结果：

CyclicBarrier

CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以它才叫做循环屏障。当所有等待线程执行完毕后它可以重置CyclicBarrier的状态并进行重用。

它的使用场景是多个线程互相等待。

---

在初始化 CyclicBarrier时需要两个参数，第一个是计数值，当调用await方法阻塞的线程数到达计数值时这些线程会冲破屏障继续执行；第二个参数值是一个Runnable任务，它将会在线程冲破屏障时被执行。

import java.util.concurrent.*;

public class Main1 {
    public static CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable() {
        @Override
        public void run() {
            System.out.println("一个阶段执行完毕...");
        }
    });
    public static void main(String[] args)  {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程1正在执行第一阶段");
                    Thread.sleep(2000);
                    cyclicBarrier.await();
                    System.out.println("线程1正在执行第二阶段");
                    Thread.sleep(2000);
                    cyclicBarrier.await();

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程2正在执行第一阶段");
                    Thread.sleep(2000);
                    cyclicBarrier.await();
                    System.out.println("线程2正在执行第二阶段");
                    Thread.sleep(2000);
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        executorService.shutdown();
    }
}

运行结果：

 

Semaphore

Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的访问线程数。

在初始化时我们可以设定一个初始值，调用release方法会递增计数器的值，而当调用acquire（permits）会去获取permits个计数器的值（默认无参时为1），若不够，当前线程会被阻塞直到有足够计数器的值被获取。

public class Main1 {
    public static Semaphore semaphore = new Semaphore(0);
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程1正在执行");
                    Thread.sleep(2000);
                    System.out.println("线程1执行完毕");
                    semaphore.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程2正在执行");
                    Thread.sleep(2000);
                    System.out.println("线程2执行完毕");
                    semaphore.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        try {
            semaphore.acquire(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("两个线程都已经执行完毕");
        executorService.shutdown();
    }
}

运行结果：