JUC三大常用工具类CountDownLatch、CyclicBarrier、Semaphore

CountDownLatch（减计数器）

概述

CountDownLatch位于 java.util.concurrent包下。

CountDownLatch是一个同步辅助类，允许一个或多个线程等待，一直到其他线程执行的操作完成后再执行。

CountDownLatch是通过一个计数器来实现的，计数器的初始值是线程的数量。每当有一个线程执行完毕后，通过countDown方法来让计数器的值-1，当计数器的值为0时，表示所有的线程都执行完毕，然后继续执行await方法之后的语句，即在锁上等待的线程就可以恢复工作了。
CountDownLatch中主要有两个方法：

• CountDown:
  • 递减锁存器的计数，如果计数达到零，则释放所有等待的线程。
  • 如果当前计数大于零，则递减。如果新计数为零，则为线程调度目的重新启用所有等待线程。
  • 如果当前计数为零，则什么也不会发生。
    
• await
  • 使当前线程等待直到门锁倒计时为零，除非线程被中断。
  • 如果当前计数为零，则此方法立即返回。即await方法阻塞的线程会被唤醒，继续执行
  • 如果当前计数大于零，则当前线程出于线程调度目的而被禁用并处于休眠状态
    

案例

简单的小例子：
一个寝室八个人要出去，需要等到1、2、3、4、5、6、7、8个人都出来，才可以锁上寝室门。即当计数器为0时，就可以执行await的方法了。

public class CountDownLatchDemo {
    public static void main(String[] args) {
        // 初始值8 有八个人需要出寝室门
        CountDownLatch countDownLatch = new CountDownLatch(8);
        for (int i = 1; i <= 8; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "出去啦");
                // 出去一个人计数器就减1
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        try {
            countDownLatch.await(); // 阻塞等待计数器归零
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 阻塞的操作 ： 计数器  num++
        System.out.println(Thread.currentThread().getName() + "====寝室人都已经出来了，关门向教室冲！！！====");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

结果

小结

CountDownLatch使用给定的计数进行初始化。 由于调用了countDown方法，每次-1， await方法会一直阻塞到当前计数达到零，然后释放所有等待线程，并且任何后续的await调用都会立即返回。 这是一种一次性现象——计数无法重置。 如果您需要重置计数的版本，请考虑使用CyclicBarrier 。
CountDownLatch一个有用属性是它不需要调用countDown线程在继续之前等待计数达到零，它只是阻止任何线程通过await,直到所有线程都可以通过。

CyclicBarrier（加法计数器）

概述

CyclicBarrier 看英文单词就可以看出大概就是循环阻塞的意思。所以还常称为循环栅栏。

CyclicBarrier 主要方法有:

public class CyclicBarrier {

    private int dowait(boolean timed, long nanos); // 供await方法调用 判断是否达到条件 可以往下执行吗
    
    //创建一个新的CyclicBarrier,它将在给定数量的参与方（线程）等待时触发，每执行一次CyclicBarrier就累加1，达到了parties，就会触发barrierAction的执行
    public CyclicBarrier(int parties, Runnable barrierAction) ;
    
    //创建一个新的CyclicBarrier ，参数就是目标障碍数,它将在给定数量的参与方（线程）等待时触发，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句
    public CyclicBarrier(int parties) 
        
	//返回触发此障碍所需的参与方数量。
    public int getParties()
	
    //等待，直到所有各方都在此屏障上调用了await 。
	// 如果当前线程不是最后一个到达的线程，那么它会出于线程调度目的而被禁用并处于休眠状态.直到所有线程都调用了或者被中断亦或者发生异常中断退出
    public int await()
	
    // 基本同上 多了个等待时间 等待时间内所有线程没有完成，将会抛出一个超时异常
    public int await(long timeout, TimeUnit unit)

    //将障碍重置为其初始状态。 
    public void reset()

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public CyclicBarrier(int parties)：的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后 的语句。可以将 CyclicBarrier 理解为加 1 操作。
public CyclicBarrier(int parties, Runnable barrierAction) ：的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，就会执行我们传入的Runnable；

案例

举一个抽奖的例子，累计抽奖200次则一定会得大奖。我们用代码模拟一下。

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        // 第一个参数：目标障碍数  第二个参数：一个Runnable任务，当达到目标障碍数时，就会执行我们传入的Runnable
        // 当我们抽了201次的时候，就会执行这个任务。
        CyclicBarrier cyclicBarrier = new CyclicBarrier(201,()->{
            System.out.println("恭喜你，已经抽奖200次，幸运值已满，下次抽奖必中大奖！！！");
        });

        for (int i=1;i<200;i++){
            final int count=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"抽奖一次");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
        // 这行代码是重置计数
        cyclicBarrier.reset();

        // 这里是我又加了 一次循环， 可以看到最后结果中输出了两次 "恭喜你"
        for (int i=1;i<=200;i++){
            final int count=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"抽奖一次");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}
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
40

小结

CyclicBarrier和CountDownLatch其实非常相似，CyclicBarrier表示加法，CountDownLatch表示减法。
区别还是有的：

CyclicBarrier只能够唤醒一个任务，CountDownLatch可以唤起多个任务。
CyclicBarrier可以重置，重新使用，但是CountDownLatch的值等于0时，就不可重复用了。

Semaphore（信号灯）

概述

Semaphore：信号量通常用于限制可以访问某些（物理或逻辑）资源的线程数。

使用场景：

限制资源，如抢位置、限流等。

案例

不知道大家有没有过在网吧抢电脑打游戏的那种经历，小时候，平常便宜点的网吧都比较小，而且也比较少，特别多的人去，去晚了的人就只有站在那里看，等别人下机才能上网。

这次的例子就是：网吧有十台高配置打游戏的电脑，有20个小伙伴想要上网。

我们用代码来模拟一下：

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 10台电脑
        Semaphore semaphore = new Semaphore(10);

        // 20 个小伙伴想要上网
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                try {
                    //等待获取许可证
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到了电脑");
                    //抢到的小伙伴，迅速就开打啦 这里就模拟个时间哈，
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //打完几把游戏的小伙伴 女朋友来找了 溜啦溜啦 希望大家都有人陪伴
                    System.out.println("女朋友来找，"+Thread.currentThread().getName() + "离开了");
                    semaphore.release();//释放资源,离开了就要把电脑让给别人啦。
                }
            }, String.valueOf(i)).start();
        }
    }


}
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

小结

在获得一个项目之前，每个线程必须从信号量中获得一个许可，以保证一个项目可供使用。 当线程完成该项目时，它会返回到池中，并且将许可返回给信号量，允许另一个线程获取该项目。 请注意，调用acquire时不会持有同步锁，因为这会阻止项目返回到池中。 信号量封装了限制访问池所需的同步，与维护池本身一致性所需的任何同步分开。
初始化为 1 的信号量，并且使用时最多只有一个许可可用，可以用作互斥锁。 这通常被称为二进制信号量，因为它只有两种状态：一种许可可用，或零许可可用。 以这种方式使用时，二进制信号量具有属性（与许多java.util.concurrent.locks.Lock实现不同），即“锁”可以由所有者以外的线程释放（因为信号量没有所有权的概念）。 这在某些特定上下文中很有用，例如死锁恢复。
此类的构造函数可以选择接受公平参数。 当设置为 false 时，此类不保证线程获取许可的顺序。 当公平性设置为真时，信号量保证调用任何acquire方法的线程被选择以按照它们对这些方法的调用的处理顺序（先进先出；FIFO）获得许可。
通常，用于控制资源访问的信号量应初始化为公平的，以确保没有线程因访问资源而饿死。 当使用信号量进行其他类型的同步控制时，非公平排序的吞吐量优势通常超过公平性考虑。
内存一致性影响：在调用“释放”方法（如release()之前线程中的操作发生在另一个线程中成功的“获取”方法（如acquire()之后的操作之前。