Semaphore

在 jdk 的注释中 是这样描述他的

一个计数信号灯。从概念上讲，信号量维护一组许可证。如有必要，每个采集模块都会阻塞，直到获得许可证，然后再获取许可证。每次发布都会添加一个许可证，可能会释放一个阻塞收单机构。然而，没有使用实际的许可证对象；信号量只是保持可用数量的计数，并相应地进行操作。
信号量通常用于限制可以访问某些（物理或逻辑）资源的线程数。

Semaphore的使用

老规矩先看代码

static void semaphoreTest () {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 10; i++) {
            executorService.submit(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName() +": 获得许可");
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }finally {
                    semaphore.release();
                    System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName() +": 释放许可");
                }
            });
        }
        executorService.shutdown();
    }
1660359070454:pool-1-thread-1: 获得许可
1660359070454:pool-1-thread-4: 获得许可
1660359070455:pool-1-thread-2: 获得许可
1660359072456:pool-1-thread-4: 释放许可
1660359072456:pool-1-thread-1: 释放许可
1660359072456:pool-1-thread-2: 释放许可
1660359072456:pool-1-thread-3: 获得许可
1660359072456:pool-1-thread-6: 获得许可
1660359072456:pool-1-thread-5: 获得许可
1660359074466:pool-1-thread-6: 释放许可
1660359074466:pool-1-thread-8: 获得许可
1660359074466:pool-1-thread-7: 获得许可
1660359074466:pool-1-thread-5: 释放许可
1660359074466:pool-1-thread-3: 释放许可
1660359074466:pool-1-thread-9: 获得许可
1660359076470:pool-1-thread-8: 释放许可
1660359076470:pool-1-thread-10: 获得许可
1660359076470:pool-1-thread-7: 释放许可
1660359076470:pool-1-thread-9: 释放许可
1660359078472:pool-1-thread-10: 释放许可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

从上边的代码中可以看出
信号量通常用于限制可以访问某些（物理或逻辑）资源的线程数。在上面的代码中可以看出 最多运行的资源数只有三个

Semaphore 应用场景

Semaphore可以用于做流量控制，特别是公用资源有限的应用场景，比如数据库连接。假 如有一个需求，要读取几万个文件的数据，因为都是IO密集型任务，我们可以启动几十个线程 并发地读取，但是如果读到内存后，还需要存储到数据库中，而数据库的连接数只有10个，这 时我们必须控制只有10个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连 接。这个时候，就可以使用Semaphore来做流量控制，

CyclicBarrier

在 jdk 的注释中 是这样描述他的

一种同步辅助工具，允许一组线程都等待对方到达一个公共障碍点。CyclicBarrier在涉及固定大小的线程组的程序中很有用，这些线程偶尔必须相互等待。该屏障被称为循环屏障，因为它可以在等待线程释放后重新使用。

它要做的事情就是让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行

但在使用中需要注意的是 线程的数量 和 CyclicBarrier 构造函数中 parties 的数量要保持一直，以为他只维护了一个计数器，如果说线程数量是 4 CyclicBarrier 构造函数 的数量是三，那个 第四个线程执行时 会一直 Await，同样 如果 Await 三次 4个线程同样可以执行完成，但是这样就无法保证不同线程 是否到达 同一个 障碍点。

CyclicBarrier 的使用

这里设置 三个线程数 同时 CyclicBarrier 允许的一组线程数为三

static void  cyclicBarrierTest () {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        for (int i = 0; i < 3; i++) {
            executorService.submit(() -> {
                try {
                    System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName() +": 正在准备");
                    TimeUnit.SECONDS.sleep(2);
                    cyclicBarrier.await();
                    System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName() +": 正在执行");
                    TimeUnit.SECONDS.sleep(2);
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (BrokenBarrierException e) {
                    throw new RuntimeException(e);
                } finally {
                    System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName() +": 执行完成");
                }
            });
        }
        executorService.shutdown();
    }
1660362890906:pool-1-thread-3: 正在准备
1660362890906:pool-1-thread-2: 正在准备
1660362890906:pool-1-thread-1: 正在准备
1660362892916:pool-1-thread-3: 正在执行
1660362892916:pool-1-thread-2: 正在执行
1660362892916:pool-1-thread-1: 正在执行
1660362894925:pool-1-thread-3: 执行完成
1660362894925:pool-1-thread-1: 执行完成
1660362894925:pool-1-thread-2: 执行完成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

从上面的代码中可以看出 必须有足够 3 的线程到达障碍点 才能继续向下执行 ， 同时他可以设置多个障碍点

** CyclicBarrier还提供一个更高级的构造函数CyclicBarrier（int parties，Runnable barrier- Action），用于在线程到达屏障时，优先执行barrierAction**
在 barrierAction 中打印 优先执行了 A

static void  cyclicBarrierTest01 () {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> {
            System.out.println(System.currentTimeMillis() + ":" + Thread.currentThread().getName() + ": 优先执行了 A");
        });
        for (int i = 0; i < 3; i++) {
            executorService.submit(() -> {
                try {
                    System.out.println(System.currentTimeMillis() + ":" + Thread.currentThread().getName() + ": 正在准备");
                    TimeUnit.SECONDS.sleep(2);
                    cyclicBarrier.await();
                    System.out.println(System.currentTimeMillis() + ":" + Thread.currentThread().getName() + ": 正在执行");
                    TimeUnit.SECONDS.sleep(2);
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (BrokenBarrierException e) {
                    throw new RuntimeException(e);
                } finally {
                    System.out.println(System.currentTimeMillis() + ":" + Thread.currentThread().getName() + ": 执行完成");
                }
            });
        }
    }
1660363624132:pool-1-thread-1: 正在准备
1660363624132:pool-1-thread-3: 正在准备
1660363624132:pool-1-thread-2: 正在准备
1660363626142:pool-1-thread-2: 优先执行了 A
1660363626143:pool-1-thread-2: 正在执行
1660363626143:pool-1-thread-3: 正在执行
1660363626143:pool-1-thread-1: 正在执行
1660363628149:pool-1-thread-3: 优先执行了 A
1660363628149:pool-1-thread-3: 执行完成
1660363628149:pool-1-thread-1: 执行完成
1660363628149:pool-1-thread-2: 执行完成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

CyclicBarrier 应用场景

CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场景。例如，用一个Excel保 存了用户所有银行流水，每个Sheet保存一个账户近一年的每笔银行流水，现在需要统计用户 的日均银行流水，先用多线程处理每个sheet里的银行流水，都执行完之后，得到每个sheet的日 均银行流水，最后，再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流水，

CountDownLatch

CountDownLatch允许一个或多个线程等待其他线程完成操作。

一种同步辅助工具，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。使用给定计数初始化倒计时锁存器。由于调用倒计时方法，等待方法一直阻塞，直到当前计数达到零，然后释放所有等待线程，并立即返回任何后续的等待调用。这是一种一次性现象——计数无法重置。如果需要重置计数的版本，请考虑使用CyclicBarrier。

计数器必须大于等于0，只是等于0时候，计数器就是零，调用await方法时不会 阻塞当前线程。CountDownLatch不可能重新初始化或者修改CountDownLatch对象的内部计数 器的值。一个线程调用countDown方法happen-before，另外一个线程调用await方法。

CountDownLatch的使用

static void  countDownLatchTest () {
                ExecutorService executorService = Executors.newFixedThreadPool(3);
        CountDownLatch countDownLatch = new CountDownLatch(3);
        for (int i = 0; i < 3; i++) {
            executorService.submit(() -> {
                try {
                    System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName() +": 执行完成");
                    TimeUnit.SECONDS.sleep(2);
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }finally {
                }
            });
        }
        try {
            countDownLatch.await();
            System.out.println("线程全部执行完成");
        } catch (InterruptedException e) {
        }finally {
            executorService.shutdown();
        }
    }
1660364051584:pool-1-thread-3: 执行完成
1660364051584:pool-1-thread-2: 执行完成
1660364051584:pool-1-thread-1: 执行完成
线程全部执行完成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

CountDownLatch 应用场景

假如有这样一个需求：我们需要解析一个Excel里多个sheet的数据，此时可以考虑使用多 线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要提示解析完 成。在这个需求中，要实现主线程等待所有线程完成sheet的解析操作

CyclicBarrier 和 CountDownLatch 的区别

• CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置。所以CyclicBarrier能处理更为复杂的业务场景。例如，如果计算发生错误，可以重置计数 器，并让线程重新执行一次。
• CyclicBarrier还提供其他有用的方法，比如getNumberWaiting方法可以获得Cyclic-Barrier 阻塞的线程数量。isBroken()方法用来了解阻塞的线程是否被中断。