Java并发工具篇

作者：汤圆

个人博客：javalover.cc

前言

随着天气的逐渐变热，整个人也开始浮躁不安

当然这里说的不是我，因为我是一个比较安静的人

讲的是隔壁的老大哥，在训斥年幼的孩子

一通吼叫过后，男人安静了下来，孩子也哭个不停

简介

前面我们介绍了 JUC 中的并发容器，它相当于一个同步容器的升级版，很大程度上提高了并发的性能

今天我们来介绍 JUC 中的并发工具，它主要是通过改变自身的状态来控制线程的执行流程；

常见的有如下几种：

  • CountDownLatch：倒计时器（属于闭锁的一种实现），用来阻塞线程
  • CyclicBarrier：循环栅栏，类似倒计时器，但是比他更高级，也是用来阻塞线程（只不过阻塞的方式不同，下面会具体介绍）
  • Semaphore：信号量，用来控制多个线程同时访问指定的资源，比如我们常用的数据库连接池

下面让我们开始吧

文章如果有问题，欢迎大家批评指正，在此谢过啦

目录

  1. 什么是并发工具
  2. 倒计数器 CountDownLatch
  3. 倒计数器升级版 CyclicBarrier【循环栅栏】
  4. 信号量 Semaphore
  5. 区别

正文

1. 什么是并发工具

并发工具是一组工具类，主要是用来控制线程的执行流程，比如阻塞某个线程，以等待其他线程

2. 倒计数器 CountDownLatch

从字面意思来看，就是一个倒计数门闩（shuan，打了半天zha就是打不出来)

通俗一点来说，就是倒计数，时间一到，门闩就打开

注：一旦打开，就不能再合上，即这个 CountDownLatch 的状态改变是永久不可恢复的（记住这个点，后面会有对比）

比较官方的说法：倒计数器用来阻塞某个（某些）线程，以等待其他多个线程的任务执行完成（以这个说法为准，上面的可以用来对比参考）

下面列出 CountDownLatch 的几个方法：

  • 构造方法：public CountDownLatch(int count)，其中count就是我们所说的内部状态（当count=0时，表示到达终止状态，此时会恢复被阻塞的线程）

  • 修改状态：public void countDown()，该方法会递减上面的count状态，每执行一次，就-1；（当count=0时，表示到达终止状态，此时会恢复被阻塞的线程）

  • 等待：public void await()，该方法会阻塞当前线程，直到count状态变为0，才会恢复执行（除非中断，此时会抛出中断异常）

  • 超时等待：public boolean await(long timeout, TimeUnit unit)，类似上面的await,只不过可以设置超时时间，等过了超时时间，还在阻塞，则直接恢复

  • 获取状态值 count：public long getCount()，获取count的数值，以查看还可以递减多少次（多用来调试）

模拟场景的话，这里先列举三个，肯定还有其他的

  • 第一个就是计数器了，最直接的
  • 第二个就是统计任务执行时长
  • 第三个就是多人5V5游戏，等所有人加载完毕，就开始游戏

下面我们以第三个场景为例，写个例子：多人游戏加载画面

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 1. 构造一个倒计数器，给定一个状态值10
        CountDownLatch latch = new CountDownLatch(10);
        System.out.println("准备加载");
      	// 这里我们创建10个线程，模拟 5V5 游戏的10个玩家
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                // 这里我们给点延时，模拟网络延时
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"加载100%");
                // 2. 这里的countDown就是用来改变倒计数器的内部状态，每次-1
                latch.countDown(); //这里不会阻塞当前线程，执行完后就立马返回了
            }).start();
        }
        // 3. 这里阻塞等待状态的完成，即10变为0;
        latch.await();
        System.out.println("所有人加载完成，开始游戏");
    }
}

输出如下：

准备加载
Thread-0加载100%
Thread-1加载100%
Thread-2加载100%
Thread-3加载100%
Thread-4加载100%
Thread-5加载100%
Thread-6加载100%
Thread-8加载100%
Thread-9加载100%
Thread-7加载100%
所有人加载完成，开始游戏

这里倒计数器的作用就是阻塞主线程，以等待其他10个子线程，等到都准备好，再恢复主线程

它的特点就是：一次性使用，达到终止状态后不能再改变

3. 倒计数器升级版 CyclicBarrier【循环栅栏】

循环栅栏，类似倒计数器，也是用来阻塞线程，不过它的重点在于循环使用

而倒计数器只能用一次（这属于他们之间最明显的一个区别）

PS：猜测之所以叫循环栅栏，而不是循环门闩，可能是因为栅栏的作用比门闩更强大，所以叫栅栏更适合吧

官方说法：循环栅栏一般用来表示多个线程之间的相互等待（阻塞）

比如有10个线程，都要await等待；那要等到最后一个线程await时，栅栏才会打开

如果有定义栅栏动作，那么当栅栏打开时，会执行栅栏动作

栅栏动作就是：栅栏打开后需执行的动作，通过构造函数的Runnable参数指定，可选参数，下面会介绍

这个属于循环栅栏和倒计数器的第二个区别：

  • 循环栅栏强调的是多个被阻塞线程之间的相互协作关系（等待）
  • 而倒计数器强调的是单个（或多个）线程被阻塞，来等待其他线程的任务执行

下面我们看几个循环栅栏 CyclicBarrier 内部的方法：

  • 构造方法：public CyclicBarrier(int parties, Runnable barrierAction)，第一个表示需等待（阻塞）的线程数，第二个barrierAction就是上面我们说的栅栏动作，即当最后一个线程也被阻塞时，就会触发这个栅栏动作（这个参数可选，如果没有，则不执行任何动作）
  • 等待：public int await()，阻塞当前线程，直到最后一个线程被阻塞，才会恢复
  • 超时等待：public boolean await(long timeout, TimeUnit unit)，类似上面的await,只不过可以设置超时时间
  • 获取当前等待的线程数：public int getNumberWaiting()，即调用了await方法的线程数量

场景：

  • 大事化小，小事合并：就是将某个大任务拆解为多个小任务，等到小任务都完成，再合并为一个结果

  • 多人对战游戏团战

    • 上面的倒计数器表示游戏开始前的准备工作（只需准备一次）
    • 而这里的循环栅栏则可以表示游戏开始后的团战工作（可团战多次）

下面看下例子：多人游戏团战画面

public class CyclicBarrierDemo {
    public static void main(String[] args) throws InterruptedException {

        // 1. 创建一个循环栅栏，给定等待线程数10和栅栏动作
        CyclicBarrier barrier = new CyclicBarrier(10,()->{
            // 栅栏动作，等到所有线程都await，就会触发
            System.out.println("=== 人齐了，开始团吧");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("=== 准备第一波团战 ===");
        // 2. 创建10个线程，模拟10个玩家
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    // 玩家到场
                    System.out.println(Thread.currentThread().getName()+"=>第一波团，我准备好了");
                    // 等待其他人，等人齐就可以团了（人齐了会执行栅栏动作，此时这边也会恢复执行）
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        // 3. 查询当前等待都线程数量，如果不为0，则主线程继续等待
        while (barrier.getNumberWaiting()!=0){
            Thread.sleep(1000);
        }
        System.out.println("=== 第一波团战结束 ===");
        
        // 4. 此时还可以进行第二波第三波团战。。。（循环栅栏可循环触发，倒计数器只能触发一次）
        
    }
}

输出如下：

=== 准备第一波团战 ===
Thread-0=>第一波团，我准备好了
Thread-1=>第一波团，我准备好了
Thread-2=>第一波团，我准备好了
Thread-3=>第一波团，我准备好了
Thread-4=>第一波团，我准备好了
Thread-5=>第一波团，我准备好了
Thread-6=>第一波团，我准备好了
Thread-7=>第一波团，我准备好了
Thread-8=>第一波团，我准备好了
Thread-9=>第一波团，我准备好了
=== 人齐了，开始团吧
=== 第一波团战结束 ===

4. 信号量 Semaphore

信号量主要是用来控制多个线程同时访问指定资源，比如数据库连接池，超过指定数量，就阻塞等待

下面我们介绍下信号量的几个关键方法：

  • 构造方法：public Semaphore(int permits, boolean fair),第一个参数为许可数，即允许同时访问的的线程数，第二个参数为公平还是非公平模式（默认非公平）
    • 公平模式，谁先调用acquire，谁就先访问资源，FIFO先进先出
    • 非公平模式，允许插队，如果某个线程刚释放了许可，另一个线程就调用了acquire，那么这个线程就会插队访问资源）
  • 获取许可：public void acquire()，如果有许可，则直接返回，并将许可数递减1；如果没可用的许可，就阻塞等待，或者被中断
  • 尝试获取许可：public boolean tryAcquire()，类似上面的acquire，但是不会被阻塞和中断，因为如果没有可用的许可，则直接返回false
  • 释放许可：public void release() ，释放一个许可，并将许可数递增1
  • 获取可用的许可数量：public int availablePermits() ，这个方法一般用来调试

场景：数据库连接池

信号量的特点就是可重复使用许可，所以像数据库连接池这种场景就很适合了

这里就不举例子了，就是多个线程acquire和release，获取许可时，如果没有就阻塞，如果有就立即返回

5 区别

用表格看比较方便点

区别 CountDownLatch CyclicBarrier Semaphore
可使用次数 单次 多次（循环使用） 多次（循环使用）
线程的阻塞 阻塞单个（多个）线程，以等待其他线程的执行 多个线程之间的相互阻塞 超过许可数，会阻塞
场景 1. 计数器
2. 统计任务执行时长
3. 多人对战游戏的开局等待		 1. 大事化小，再合并
2. 多人对战游戏的团战		 1. 数据库连接池

可以看到，倒计数器主要是用来表示单个线程等待多个线程，而循环栅栏主要是用来表示多个线程之间的相互等待

总结

  1. 什么是并发工具：并发工具是一组工具类，主要是用来控制线程的执行流程，比如阻塞某个线程，以等待其他线程
  2. 倒计数器 CountDownLatch：用来表示阻塞某个（某些）线程，以等待其他多个线程的任务执行完成
  3. 循环栅栏 CyclicBarrier：用来表示多个线程之间的相互等待协作（阻塞）
  4. 信号量 Semaphore：用来表示允许同时访问指定资源的许可数（线程数）
  5. 区别：
区别 CountDownLatch CyclicBarrier Semaphore
可使用次数 单次 多次（循环使用） 多次（循环使用）
线程的阻塞 阻塞单个（多个）线程，以等待其他线程的执行 多个线程之间的相互阻塞 超过许可数，会阻塞
场景 1. 计数器
2. 统计任务执行时长
3. 多人对战游戏的开局等待		 1. 大事化小，再合并
2. 多人对战游戏的团战		 1. 数据库连接池

参考内容：

  • 《Java并发编程实战》
  • 《实战Java高并发》

后记

学习之路，真够长，共勉之

写在最后：

愿你的意中人亦是中意你之人

posted @ 2021-05-12 11:35  汤圆学Java  阅读(592)  评论(2)  编辑  收藏  举报