Java 中的并发工具类详解:Semaphore、CountDownLatch 和 CyclicBarrier

目录

1、信号量:Semaphore

2、线程同步:CountDownLatch 和 CyclicBarrier 


Java 并发包提供了哪些并发工具类?

        我们通常所说的并发包也就是 java.util.concurrent 及其子包,集中了 Java 并发的各种基础工具类,具体主要包括几个方面:

  1. 提供了比 synchronized 更加高级的各种同步结构,包括 CountDownLatch、CyclicBarrier、Semaphore 等,可以实现更加丰富的多线程操作,比如利用 Semaphore 作为资源控制器,限制同时进行工作的线程数量。
  2. 各种线程安全的容器,比如最常见的 ConcurrentHashMap、有序的 ConcurrentSkipListMap,或者通过类似快照机制,实现线程安全的动态数组 CopyOnWriteArrayList 等。
  3. 各种并发队列实现,如各种 BlockingQueue 实现,比较典型的 ArrayBlockingQueue、 SynchronousQueue 或针对特定场景的 PriorityBlockingQueue 等。
  4. 强大的 Executor 框架,可以创建各种不同类型的线程池,调度任务运行等,绝大部分情况下,不再需要自己从头实现线程池和任务调度器。

        首先,我们来看看并发包提供的丰富同步结构:

  • CountDownLatch,允许一个或多个线程等待某些操作完成。// 同步等待
  • CyclicBarrier,一种辅助性的同步结构,允许多个线程等待到达某个屏障。// 同步等待
  • Semaphore,Java 版本的信号量实现。// 信号量

1、信号量:Semaphore

        Java 提供了经典信号量(Semaphore)的实现,它通过控制一定数量的允许(permit)的方式,来达到限制通用资源访问的目的。你可以想象一下这个场景,在车站、机场等出租车时,当很多空出租车就位时,为防止过度拥挤,调度员指挥排队等待坐车的队伍一次进来 5 个人上车,等这 5 个人坐车出发,再放进去下一批,这和 Semaphore 的工作原理有些类似。

        试试使用 Semaphore 来模拟实现这个调度过程:

import java.util.concurrent.Semaphore;

/**
 * 信号量:获取到信号量的程序,允许继续向下执行,比如电影院的固定座位数量
 */
public class UsualSemaphoreSample {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("Action...GO!");
        // 获取到信号量的程序,允许继续向下执行
        Semaphore semaphore = new Semaphore(5); // 初始化5个信号量
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(new SemaphoreWorker(semaphore));
            t.start();
        }
    }
}

class SemaphoreWorker implements Runnable {

    private String    name;
    private Semaphore semaphore;

    public SemaphoreWorker(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    @Override
    public void run() {
        try {
            log("尝试获取一个信号量!");
            semaphore.acquire(); // 获取一个信号量,如果获取不到信号量,将在这里被阻塞
            log("获取到信号量,继续执行...!");
            Thread.sleep(1000); // 模拟程序执行时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            log("释放一个信号量!");
            semaphore.release(); // 释放一个信号量
        }
    }

    private void log(String msg) {
        if (name == null) {
            name = Thread.currentThread().getName();
        }
        System.out.println(name + " " + msg);
    }
}

        这段代码是比较典型的 Semaphore 示例,其逻辑是,线程试图获得工作允许,得到许可则进行任务,然后释放许可,这时等待许可的其他线程,就可获得许可进入工作状态,直到全部处理结束。

        编译运行,我们就能看到 Semaphore 的允许机制对工作线程的限制。

Java 中的并发工具类详解:Semaphore、CountDownLatch 和 CyclicBarrier_第1张图片

        但是,从具体节奏来看,其实并不符合我们前面场景的需求,因为本例中 Semaphore 的用法实际是保证,一直有 5 个人可以试图乘车,如果有 1 个人出发了,立即就有排队的人获得许可,而这并不完全符合我们前面的要求。

        那么,我再修改一下,演示个非典型的 Semaphore 用法。

import java.util.concurrent.Semaphore;

/**
 * 信号量:获取到信号量的程序,允许继续向下执行,比如电影院的固定座位数量
 */
public class AbnormalSemaphoreSample {

    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(0);    // 初始化信号量为 0
        for (int i = 0; i < 10; i++) {             // 准备好使用场景
            Thread t = new Thread(new MyWorker(semaphore));
            t.start();
        }
        System.out.println("Action...GO!");
        semaphore.release(5);                      // 释放 5 个信号量
        System.out.println("等待信号量用尽...");
        while (semaphore.availablePermits() != 0) {
            Thread.sleep(1000L);                   // 信号量没有用尽,一直循环阻塞
        }
        System.out.println("Action...GO again!");
        semaphore.release(5);
    }
}

class MyWorker implements Runnable {

    private Semaphore semaphore;

    public MyWorker(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    @Override
    public void run() {
        try {
            semaphore.acquire();  // 获取一个信号量
            System.out.println("Executed!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Java 中的并发工具类详解:Semaphore、CountDownLatch 和 CyclicBarrier_第2张图片

        注意,上面的代码,更侧重的是演示 Semaphore 的功能以及局限性,其实有很多线程编程中的反实践,比如使用了 sleep() 来协调任务执行,而且使用轮询调用 availalePermits() 来检测信号量获取情况,这都是很低效并且脆弱的,通常只是用在测试或者诊断场景。

        总的来说,我们可以看出 Semaphore 就是个计数器,其基本逻辑基于 acquire/release,并没有太复杂的同步逻辑。

        如果 Semaphore 的数值被初始化为 1,那么一个线程就可以通过 acquire 进入互斥状态,本质上和互斥锁是非常相似的。但是区别也非常明显,比如互斥锁是有持有者的,而对于 Semaphore 这种计数器结构,虽然有类似功能,但其实不存在真正意义的持有者,除非我们进行扩展包装。

2、线程同步:CountDownLatch 和 CyclicBarrier 

        下面,来看看 CountDownLatch 和 CyclicBarrier,它们的行为有一定的相似度,经常会被考察二者有什么区别,简单总结一下:

  1. CountDownLatch 是不可以重置的,所以无法重用;而 CyclicBarrier 则没有这种限制,可以重用。
  2. CountDownLatch 的基本操作组合是 countDown/await。调用 await 的线程阻塞等待 countDown 足够的次数,不管你是在一个线程还是多个线程里 countDown,只要次数足够即可。所以就像 Brain Goetz 说过的,CountDownLatch 操作的是事件// 可以在一个线程中多次的 countDown
  3. CyclicBarrier 的基本操作组合,则就是 await,当所有的伙伴(parties)都调用了 await,才会继续进行任务,并自动进行重置。注意,正常情况下,CyclicBarrier 的重置都是自动发生的,如果我们调用 reset 方法,但还有线程在等待,就会导致等待线程被打扰,抛出 BrokenBarrierException 异常。CyclicBarrier 侧重点是线程,而不是调用事件,它的典型应用场景是用来等待并发线程结束。// 一个线程只能 await 一次

        如果用 CountDownLatch 去实现上面的排队场景,该怎么做呢?假设有 10 个人排队,我们将其分成 5 个人一批,通过 CountDownLatch 来协调批次,可以试试下面的示例代码。

import java.util.concurrent.CountDownLatch;

/**
 * 同步阻塞
 */
public class LatchSample {

    public static void main(String[] args) throws InterruptedException {
        // 等待 countDown 足够的次数,然后一起执行
        CountDownLatch latch = new CountDownLatch(6); // 不可重置,无法重用
        for (int i = 0; i < 5; i++) { // 第一批线程
            Thread t = new Thread(new FirstBatchWorker(latch));
            t.start();
        }
        for (int i = 0; i < 5; i++) { // 第二批线程
            Thread t = new Thread(new SecondBatchWorker(latch));
            t.start();
        }
        // 注意这里也是演示目的的逻辑,并不是推荐的协调方式
        while (latch.getCount() != 1) { // 仅剩一个名额的时候停止等待
            Thread.sleep(1000L);
        }
        System.out.println("第一批全部执行执行完成!");
        latch.countDown(); // 填补完最后一个名额,第二批才会开始执行
    }
}

class FirstBatchWorker implements Runnable {

    private CountDownLatch latch;

    public FirstBatchWorker(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        System.out.println("第 1 批 executed!");
        latch.countDown(); // latch 次数减一
    }
}

class SecondBatchWorker implements Runnable {

    private CountDownLatch latch;

    public SecondBatchWorker(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            latch.await(); // 等待 -> latch 没达到足够的次数
            System.out.println("第 2 批 executed!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

        CountDownLatch 的调度方式相对简单,后一批次的线程进行 await,等待前一批 countDown 足够多次。这个例子也从侧面体现出了它的局限性,虽然它也能够支持 10 个人排队的情况,但是因为不能重用,如果要支持更多人排队,就不能依赖一个 CountDownLatch 进行了。其编译运行输出如下:

Java 中的并发工具类详解:Semaphore、CountDownLatch 和 CyclicBarrier_第3张图片

        在实际应用中的条件依赖,往往没有这么别扭,CountDownLatch 用于线程间等待操作结束是非常简单普遍的用法。通过 countDown/await 组合进行通信是很高效的,通常不建议使用例子里那个循环等待方式。

        如果用 CyclicBarrier 来表达这个场景呢?我们知道 CyclicBarrier 其实反映的是线程并行运行时的协调,在下面的示例里,从逻辑上,5 个工作线程其实更像是代表了 5 个可以就绪的空车,而不再是 5 个乘客,对比前面 CountDownLatch 的例子更有助于我们区别它们的抽象模型,请看下面的示例代码:// 注意:使用 CyclicBarrier 时,parties 数量应该与线程数量保持一致,一个跑道,一个线程

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 可重用的同步阻塞
 */
public class CyclicBarrierSample {

    public static void main(String[] args) throws InterruptedException {
        // 批量等待
        CyclicBarrier barrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("Action...GO again!");
            }
        });
        for (int i = 0; i < 5; i++) { // 开启 5 个线程
            Thread t = new Thread(new CyclicWorker(barrier));
            t.start();
            Thread.sleep(100);
        }
    }

    static class CyclicWorker implements Runnable {

        private CyclicBarrier barrier;

        public CyclicWorker(CyclicBarrier barrier) {
            this.barrier = barrier;
        }

        @Override
        public void run() {
            try {
                for (int i = 0; i < 3; i++) { // 分 3 个批次
                    System.out.println(Thread.currentThread().getName() + "-" + i + "-" + "准备占用名额");
                    barrier.await(); // 阻塞等待 -> 循环被阻塞
                }
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

        为了让输出更能表达运行时序,我使用了 CyclicBarrier 特有的 barrierAction,当屏障被触发时,Java 会自动调度该动作。因为 CyclicBarrier 会自动进行重置,所以这个逻辑其实可以非常自然的支持更多排队人数。其编译输出如下:

Java 中的并发工具类详解:Semaphore、CountDownLatch 和 CyclicBarrier_第4张图片

        Java 并发类库还提供了Phaser,功能与 CountDownLatch 很接近,但是它允许线程动态地注册到 Phaser 上面,而 CountDownLatch 显然是不能动态设置的。Phaser 的设计初衷是,实现多个线程类似步骤、阶段场景的协调,线程注册等待屏障条件触发,进而协调彼此间行动,具体请参考这个例子。

当 parties 值不等于线程数时的场景参考文章:

【线程 锁】栅栏 CyclicBarrier的构造函数入参parties详解_云川之下的博客-CSDN博客_cyclicbarrier 构造函数

你可能感兴趣的:(并发编程,Semaphore,CountDownLatch,CyclicBarrier,Java,并发工具类)