彻底理解Java并发：Java并发工具类

本篇内容包括：Java 并发工具类的介绍、使用方式与 Demo，包括了 CountDownLatch（线程计数器）、CyclicBarrier（回环栅栏）、Semaphore（信号量）以及 Exchanger（交换器）等内容！

CountDownLatch_4">一、CountDownLatch（线程计数器）

CountDownLatch 线程计数器，俗称闭锁，作用是类似加强版的 Join，是让一组线程等待其他的线程完成工作以后才执行

CountDownLatch 类位于 java.util.concurrent 包下，利用它可以实现类似计数器的功能。比如有一个任务 A，它要等待其他 4 个任务执行完毕之后才能执行，此时就可以利用 CountDownLatch 来实现这种功能了。

Demo（主线程等待两个子线程执行完毕后，继续执行）：

    public static void main(String[] args) throws InterruptedException {
        final CountDownLatch latch = new CountDownLatch(2);
        new Thread(() -> {
            System.out.println("子线程" + Thread.currentThread().getName() + "正在执行");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程" + Thread.currentThread().getName() + "执行完毕");
            latch.countDown();
        }).start();


        new Thread(() -> {
            System.out.println("子线程" + Thread.currentThread().getName() + "正在执行");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程" + Thread.currentThread().getName() + "执行完毕");
            latch.countDown();
        }).start();

        System.out.println("等待 2 个子线程执行完毕...");
        latch.await();
        System.out.println("2 个子线程已经执行完毕");
        System.out.println("继续执行主线程");
    }

CountDownLatch 的主要方法：

CountDownLatch()：初始化方法
public boolean await：等待方法，同时带参数的是超时重载方法
public void countDown()：每执行一次，计数器减一，就是初始化传入的数字，也代表着一个线程完成了任务
public long getCount()：获取当前值

CyclicBarrier_54">二、CyclicBarrier（回环栅栏）

CyclicBarrier 回环栅栏，俗称栅栏锁，作用是让一组线程到达某个屏障，被阻塞，一直到组内的最后一个线程到达，然后屏障开放，接着，所有的线程继续运行叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier 可以被重用。我们暂且把这个状态就叫做 barrier，当调用 await() 方法之后，线程就处于 barrier 了。

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

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

另外 CyclicBarrier 是可以重用的。

Demo（一组内 4 个线程，每个线程都等待组内所有线程到达 barrier 后，再继续执行）：

    public static void main(String[] args) {
        int n = 4;
        CyclicBarrier barrier = new CyclicBarrier(n);
        for (int i = 0; i < n; i++) {
            new Writer(barrier).start();
        }
    }

    static class Writer extends Thread {
        private final CyclicBarrier cyclicBarrier;

        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(5000); //以睡眠来模拟线程需要预定写入数据操作
                System.out.println("线程" + Thread.currentThread().getName() + "写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务，比如数据操作");
        }
    }

Semaphore_102">三、Semaphore（信号量）

Semaphore 翻译成字面意思为信号量，Semaphore 可以控制同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

Semaphore 类中比较重要的几个方法：

public void acquire()：用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。
public void acquire(int permits)：获取 permits 个许可
public void release() { } ：释放许可。注意，在释放许可之前，必须先获获得许可。
public void release(int permits) { }：释放 permits 个许可

上面 4 个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法

public boolean tryAcquire()：尝试获取一个许可，若获取成功，则立即返回 true，若获取失败，则立即返回 false
public boolean tryAcquire(long timeout, TimeUnit unit)：尝试获取一个许可，若在指定的时间内获取成功，则立即返回 true，否则则立即返回 false
public boolean tryAcquire(int permits)：尝试获取 permits 个许可，若获取成功，则立即返回 true，若获取失败，则立即返回 false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)：尝试获取 permits个许可，若在指定的时间内获取成功，则立返回 true，否则则立即返回 false
public int availablePermits()：得到可用的许可数目。

Demo（工厂有 5 台机器，有 8 个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用）：

    public static void main(String[] args) {
        int N = 8; //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for (int i = 0; i < N; i++) {
            new Worker(i, semaphore).start();
        }
    }

    static class Worker extends Thread {
        private int num;
        private Semaphore semaphore;

        public Worker(int num, Semaphore semaphore) {
            this.num = num;
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人" + this.num + "占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人" + this.num + "释放出机器");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

Exchanger_165">四、Exchanger（交换器）

Exchanger，俗称交换器，用于在线程之间交换数据，但是比较受限，因为只能两个线程之间交换数据

Exchanger 提供了一个同步点 exchange 方法，两个线程调用 exchange 方法时，无论调用时间先后，两个线程会互相等到线程到达 exchange 方法调用点，此时两个线程可以交换数据，将本线程产出数据传递给对方

Demo（商品方正在等待金钱方，使用货物兑换为金钱；金钱方正在等待商品方，使用金钱购买食物）：

    /**
     * Exchanger实例
     */
    static final Exchanger<String> exchanger = new Exchanger<String>();

    public static void main(String[] args) {
        // 模拟阻塞线程.
        new Thread(() -> {
            try {
                String wares = "红烧肉";
                System.out.println(Thread.currentThread().getName() + "商品方正在等待金钱方，使用货物兑换为金钱.");
                Thread.sleep(2000);
                String money = exchanger.exchange(wares);
                System.out.println(Thread.currentThread().getName() + "商品方使用商品兑换了" + money);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }).start();
        // 模拟阻塞线程.
        new Thread(() -> {
            try {
                String money = "人民币";
                System.out.println(Thread.currentThread().getName() + "金钱方正在等待商品方，使用金钱购买食物.");
                Thread.sleep(4000);
                String wares = exchanger.exchange(money);
                System.out.println(Thread.currentThread().getName() + "金钱方使用金钱购买了" + wares);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }).start();
    }

五、总结

CountDownLatch 和 CyclicBarrier 都能够实现线程之间的等待，只不过它们侧重点不同；CountDownLatch一般用于某个线程 A 等待若干个其他线程执行完任务之后，它才执行；而 CyclicBarrier 一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；另外，CountDownLatch 是不能够重用的，而 CyclicBarrier 是可以重用的。

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

Exchanger 用于在线程之间交换数据，但是比较受限，因为只能两个线程之间交换数据。