程序员经验分享-hwhale

Java多线程 关闭线程池 shutdown() 、shutdownNow()、awaitTermination()

2023-05-16

目录

  • 一、说明
  • 二、理解
  • 三、实现
    • 1.shutdown()
    • 2.shutdownNow()
    • 3.awaitTermination()

一、说明

ThreadPoolExecutor

  • 继承 Executor 接口
  • 它有多个构造方法来实现自定义创建线程池，以内部线程池的形式对外提供管理任务执行，线程调度，线程池管理等
  • 关闭线程池调用 shutdown() 、shutdownNow()、awaitTermination()方法

二、理解

shutdown()

  • 只关闭了提交通道，停止接收新任务，已提交的任务会继续执行直到完成，此方法不会阻塞，当所有提交任务执行完毕，线程池被关闭
public void shutdown() {
    // 上锁确保只有一个线程执行此操作
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        // 检查是否有权限关闭线程池以和中断线程
        checkShutdownAccess();
        // 将线程池状态设置为SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 中断所有空闲线程
        interruptIdleWorkers();
        // 用于取消延时任务
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
  	// 将线程池置为TERMINATED状态
    tryTerminate();
}

shutdownNow()

  • 立即停止线程池，停止接收新任务，中断所有正在执行的任务，停止对等待队列的处理，立刻返回未执行的任务列表
public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    // 上锁确保只有一个线程执行此操作
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        // 检查是否有权限关闭线程池以和中断线程
        checkShutdownAccess();
      	// 将线程池运行状态置为STOP
        advanceRunState(STOP);
      	// 中断所有线程
        interruptWorkers();
      	// 将未执行的任务移入列表中
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
  	// 将线程池置为TERMINATED状态
    tryTerminate();
    return tasks;
}

awaitTermination()

  • 在shutdown()调用之后使用，阻塞当前线程，在这之后可以继续提交任务，设置等待超时时间，等待所有任务都执行完成，检查线程池是否终止，如果终止返回 true，否则返回 false，并解除阻塞

  • 如果在超时之前所有任务执行完毕，表示线程池已经终止，返回true，否则返回false

  • 如果在shutdown()之前使用，线程池未终止，awaitTermination()锁在等待终止状态，造成死锁

    public boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException {
        // 将时间单位转化为纳秒
        long nanos = unit.toNanos(timeout);
        // 上锁确保只有一个线程执行此操作
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
         	// 如果线程池在超池之前终止，返回true
            while (!runStateAtLeast(ctl.get(), TERMINATED)) {
            // 超时但是线程池未终止，返回false
                if (nanos <= 0L)
                    return false;
            // 实现阻塞
                nanos = termination.awaitNanos(nanos);
            }
            return true;
        } finally {
            mainLock.unlock();
        }
    }

线程池的生命周期

  • 线程池的状态(runState)和工作线程数量(workerCount)共同保存在 AtomicInteger 类型的控制变量 ctl 中
  • ctl高三位保存运行状态(23=8>5)，低29位保存工作线程的数量(229-1)
	// 初始运行状态为RUNNING，线程数为0
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    // COUNT_BITS: 29
    private static final int COUNT_BITS = Integer.SIZE - 3;
    // CAPACITY: 十进制: 536870911 二进制: 00011111111111111111111111111111
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits 
    // RUNNING: 十进制:-536870912  二进制:11100000000000000000000000000000
    private static final int RUNNING    = -1 << COUNT_BITS;
    // SHUTDOWN: 十进制:0  二进制:0
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    // STOP: 十进制:536870912  二进制:00100000000000000000000000000000
    private static final int STOP       =  1 << COUNT_BITS;
    // TIDYING: 十进制:1073741824  二进制:01000000000000000000000000000000
    private static final int TIDYING    =  2 << COUNT_BITS;
    // TERMINATED: 十进制:1610612736  二进制:01100000000000000000000000000000
    private static final int TERMINATED =  3 << COUNT_BITS;
    
    // Packing and unpacking ctl 打包和解包ctl
    // 获取线程池当前状态，CAPACITY取反，高三位都是1，低29位都是0，和ctl进行与运算，获得runState变量
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    // CAPACITY高三位都是0，低29位都是0，和ctl进行与运算获得workerCount变量
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    // 初始化ctl变量，runState和workerCount进行或运算后共同存储在一个变量中
    private static int ctlOf(int rs, int wc) { return rs | wc; }
  • RUNNING 接收新的任务，并且可执行队列里的任务
  • SHUTDOWN 停止接收新任务，但可执行队列里的任务
  • STOP 停止接收新任务，不执行队列里的任务，中断正在执行的任务
  • TIDYING 所有任务都已终止，线程数为0，线程池变为TIDYING状态，会执行钩子函数terminated()，钩子方法是指使用一个抽象类实现接口，一个抽象类实现这个接口，需要的方法设置为abstract，其它设置为空方法
  • TERMINATED 终止状态，表示线程池已终止，已经执行完terminated()钩子方法

判断当前线程池运行状态

	// 判断线程池当前运行状态是否小于给定值
    private static boolean runStateLessThan(int c, int s) {
        return c < s;
    }
	// 判断线程池当前运行状态是否大于等于给定值
    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }
	// 判断线程池是否处于RUNNING状态
    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }
	 // 判断线程池是否处于SHUTDOWN状态
    public boolean isShutdown() {
        return ! isRunning(ctl.get());
    }
	 // 判断线程池是否处于TERMINATING状态
    public boolean isTerminating() {
        int c = ctl.get();
        return ! isRunning(c) && runStateLessThan(c, TERMINATED);
    }
	 // 判断线程池是否处于TERMINATED状态
    public boolean isTerminated() {
        return runStateAtLeast(ctl.get(), TERMINATED);
    }

运行状态转换关系

在这里插入图片描述

三、实现

1.shutdown()

创建一个ShutdownTest类，默认使用ThreadPoolExecutor.AbortPolicy拒绝策略，队列是ArrayBlockingQueue，设置核心线程数最大值为1，线程池线程数最大值为2，最大等待时间为5秒，等待队列值为2，提交8个任务，在第5个任务的时候执行 shutdown()

public class ShutdownTest {
    public static void main(String[] args) {
        // 1.创建线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2),
                Executors.defaultThreadFactory());
        // 2.创建线程任务
        for (int i = 1; i <= 8; i++) {

            // 3.执行任务
            System.out.println("执行第"+i+"个任务");

                threadPoolExecutor.execute(new runnable("任务"+i));
                // 4.获取等待队列
                Iterator iterator = threadPoolExecutor.getQueue().iterator();
                System.out.print("当前等待队列 ");
                while (iterator.hasNext()){
                    runnable thread = (runnable) iterator.next();
                    System.out.print(thread.name + "\t");
                }
                System.out.print("\n");
                System.out.println("--------");

            // 5.关闭线程池
            if (i == 4) {
                threadPoolExecutor.shutdown();
                System.out.println("线程池已关闭");
            }
        }
    }

    static class runnable implements Runnable{
        // 设置任务名
        String name;
        public runnable(String setName) {
            this.name = setName;
        }
        @Override
        public void run() {
            try {
                System.out.println("线程:"+Thread.currentThread().getName() +" 执行: "+name);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

执行 shutdown()，此时停止接收新任务，已提交的任务会继续执行直到完成，此方法不会阻塞，抛出RejectedExecutionException
在这里插入图片描述

如果捕获RejectedExecutionException，可以看到任务被拒绝了

    public static void main(String[] args) {
        // 1.创建线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2),
                Executors.defaultThreadFactory());
        // 2.创建线程任务
        for (int i = 1; i <= 8; i++) {

            // 3.执行任务
            System.out.println("执行第"+i+"个任务");
            try {
                threadPoolExecutor.execute(new runnable("任务"+i));
                // 4.获取等待队列
                Iterator iterator = threadPoolExecutor.getQueue().iterator();
                System.out.print("当前等待队列 ");
                while (iterator.hasNext()){
                    runnable thread = (runnable) iterator.next();
                    System.out.print(thread.name + "\t");
                }
                System.out.print("\n");
                System.out.println("--------");
            } catch (RejectedExecutionException e) {
                // 5.捕获拒绝执行策略异常
                System.out.println("拒绝执行第" + i + "个任务");
            }
            // 6.关闭线程池
            if (i == 4) {
                threadPoolExecutor.shutdown();
                System.out.println("线程池已关闭");
            }
        }
    }

在这里插入图片描述

2.shutdownNow()

立即停止线程池，停止接收新任务，中断所有正在执行的任务，停止对等待队列的处理

            // 6.关闭线程池
            if (i == 4) {
                threadPoolExecutor.shutdownNow();
                System.out.println("线程池已关闭");
            }

在这里插入图片描述

3.awaitTermination()

此方法阻塞，在shutdown()调用之后，停止接收新任务，但是awaitTermination()后可以继续提交，此方法是阻塞的，用来检测timeout时间后线程池是否终止，如果停止，则返回true并释放锁

public class ShutdownTest {
    public static void main(String[] args) throws InterruptedException {
        // 1.创建线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2),
                Executors.defaultThreadFactory());
        // 2.创建线程任务
        for (int i = 1; i <= 8; i++) {

            // 3.执行任务
            System.out.println("执行第"+i+"个任务");
            try {
                threadPoolExecutor.execute(new runnable("任务"+i));
                // 4.获取等待队列
                Iterator iterator = threadPoolExecutor.getQueue().iterator();
                System.out.print("当前等待队列 ");
                while (iterator.hasNext()){
                    runnable thread = (runnable) iterator.next();
                    System.out.print(thread.name + "\t");
                }
                System.out.print("\n");
                System.out.println("--------");
            } catch (RejectedExecutionException e) {
                // 5.捕获拒绝执行策略异常
                System.out.println("拒绝执行第" + i + "个任务");
            }
            // 6.关闭线程池
            if (i == 4) {
                threadPoolExecutor.shutdown();
                while (!threadPoolExecutor.awaitTermination(1, TimeUnit.SECONDS)) {
                    System.out.println("线程池未关闭");
                }
                System.out.println("线程池已经关闭");
            }
        }
    }

    static class runnable implements Runnable{
        // 设置任务名
        String name;
        public runnable(String setName) {
            this.name = setName;
        }
        @Override
        public void run() {
            try {
                System.out.println("线程:"+Thread.currentThread().getName() +" 执行: "+name);
                Thread.sleep(5000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

保证了线程池和其他线程的之间的执行顺序
在这里插入图片描述

如果 shutdown() 在 awaitTermination()后调用的话，awaitTermination()依然锁在等待终止状态，而 shutdown() 也无法得到锁去让线程池停止，这就形成了死锁

            // 6.关闭线程池
            if (i == 4) {
                while (!threadPoolExecutor.awaitTermination(1, TimeUnit.SECONDS)) {
                    System.out.println("线程池未关闭");
                }
                threadPoolExecutor.shutdown();
                System.out.println("线程池已经关闭");
            }

在这里插入图片描述

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java多线程 关闭线程池 shutdown() 、shutdownNow()、awaitTermination() 的相关文章

  • 12：企业规范约束-MySQL

    目录 12 1 库表字段约束规范12 2 索引规范12 3 SQL开发约束规范12 4 其他规范 12 1 库表字段约束规范 字段名 xff1a is vip unsigned tinyint 长度为1mysql命名是不区分大小写的 xff

  • Java与生活

    目录 一带而过 0 0 前言 1 1 Java是怎么执行的 xff1f 说好的exe呢 xff1f 1 2 package 1 3 第一个程序的讲解 1 4 注释和文档 2 0 一带而过 2 1 字符串演示 2 2 字符串结束符的那些事儿

  • 一带而过-Java与生活

    目录 认识Java0 0 前言1 1 Java是怎么执行的 xff1f 说好的exe呢 xff1f 1 2 package1 3 第一个程序的讲解1 4 注释和文档2 0 一带而过2 1 字符串演示2 2 字符串结束符的那些事儿2 3 自动

  • 0：Linux的初步认识-步入Linux的现代方法

    目录 0 0 系统的认识0 1 Linux操作系统认识 xff0c 以及开源的提出 xff1a Linux的千奇百怪的版本0 2 开源的含义0 3 Linux的用途 xff0c 各类发行版本 0 0 系统的认识 什么是系统 xff1f 鼠标

  • 1：VMware虚拟机的使用-步入Linux的现代方法

    目录 1 1 Vmware虚拟机1 2 VMware 161 3 关于从15更新到16的说法 1 1 Vmware虚拟机 安装系统的方式 实体机双系统虚拟机 详见 xff1a VMware Workstation 虚拟机权威指南 零基础虚拟

  • 2：发行版本安装演示——Ubuntu、CentOS、Kali？-步入Linux的现代方法

    目录 2 1 先尝试Ubuntu2 2 VMware Tools2 3 Ubuntu 20 04设置2 4 Linux其他发行版本的安装指导2 5 下载指导 2 1 先尝试Ubuntu 详见 xff1a Linux Ubuntu 零基础体验

  • 3：步入Linux的世界-步入Linux的现代方法

    目录 3 1 Linux究竟需要我们学习什么 xff1f Linux四大组成部分3 2 Linux是命令还是图形界面 xff1f GUI 是什么 xff1f 那GNU是什么东西 xff1f GNU Linux 和Linux有什么区别 xff

  • Linux中 sudo su 和 su 区别

    su 直接切换root用户 xff0c 需输入root密码ubuntu xff0c 默认没有设置root密码 xff0c 使用sudo passwd root设置root密码 sudo su 当前用户暂时申请root权限 xff0c 需输入

  • Python 使用 Qt5 实现水平导航栏

    在 Qt5 中可以使用 QWidget 包含两个水平布局 xff0c 通过点击水平布局里的按钮 xff0c 实现下标滑动与页面的切换 可以按照以下步骤来实现上面图片中的功能 xff1a 导入必要的 Qt 包 xff1a span class

  • OOP上半部分-Java与生活

    目录 1 1 1 问题产生和引导1 1 2 烦人1 1 3 变换思维1 1 4 规划明确目标站在更高层次思考问题1 1 5 上代码 xff0c 设计体验面向对象编程 xff0c 实例和对象1 1 6 去你md成员变量行为类和this1 1

  • Centos7 搭建Jupyter NoteBook教程

    目录 1 Anaconda31 1 下载1 2 安装 2 环境配置2 1 添加PATH到 root bashrc文件中2 2 激活配置的环境变量 3 搭建虚拟环境3 1 创建虚拟环境3 2 开启环境3 3 查看已有的虚拟环境 4 jupyt

  • OOP下半部分-Java与生活

    目录 面向对象三大特性 xff1a 封装 继承 多态2 1 1 需求重定义2 1 2 继承2 2 2 饿狼传说之多层继承2 2 3 方法的重写2 2 4 super啃老2 2 5 啃老啃到彻底2 2 6 final2 2 7 提出新的问题2

  • Centos7 搭建单机Spark分布式集群

    目录 1 JDK Hadoop Spark安装与配置1 1 解压包1 2 配置环境变量 2 Scala安装与配置2 1 Scala安装2 2 配置环境变量 3 配置集群3 1 配置sprak3 2 启动spark 4 问题 xff1a 虚拟

  • 面向对象大胆向前 Java API 实战

    目录 0 xff1a Base API 引言API的定义和用处ScannerNumberMathRandomThreadLocalRandomDateDateFormat和SimpleDateFormatCalendarSystem 详见

  • Yeats_Liao的书单

    计算机软件类 大话计算机 冬瓜哥 架构师的自我修炼 李智慧 图解算法 xff1a 使用C语言 吴灿铭 胡昭民 编程原则 马克思 卡纳特 亚历山大 啊哈 xff01 算法 啊哈磊 Java Web框架开发技术 Spring 43 Spring

  • 0：Base API-Java API 实战

    目录 0 1 引言0 2 API的定义和用处0 3 Scanner xff08 普通类 xff09 0 4 Number xff08 包装类 xff09 0 5 Math xff08 工具类 xff09 0 6 Random xff08 父

  • 黑客与画家 [美] Paul Graham 读书摘录

    充分理解程序员带来的美和智慧 xff0c 这是本书做到的 P15 为什么书呆子不受欢迎 xff1f 平庸带来的严重后果 xff0c 直接导致学生的叛逆心理 我误解最深的一个词是 老成 tact 成年人使用这个词 xff0c 含义似乎就是 闭

  • 教育的真谛 [英] 尼古拉斯·泰特 读书摘录

    自柏拉图以来 xff0c 教育的目的与性质始终是西方哲学传统关注和探讨的问题 纵览2500年来的思想成果 xff0c 作者尼古拉斯 泰特博士在 教育的真谛 xff1a 伟大思想家的观点及其现实意义 中指出 xff0c 人类的教育活动至少应包

  • 1：Unit test and main function-Java API 实战

    目录 1 抛出企业问题 xff0c 脱离main测试 xff0c 模块化编程2 Junit单元测试的含义和用途3 怎么获取各种Jar包 xff1f Maven Repository 获取各类各个版本的jar xff0c 这就是仓库 脱离老师

  • CentOS 安装 Samba服务器（多用户组、多用户有不同的访问权限）

    增加smb用户 root 64 localhost sir01 smbpasswd a linuxsir 查看 smb 现有用户 pdbedit L 验证用户登录文件夹 smbclient 192 168 101 93 forlder U

随机推荐

  • 2：StringBuilder-Java API 实战

    目录 1 String存在的问题2 Stringbuilder以及链式调用的含义 1 String存在的问题 认识String 字符串广泛应用在编程中 xff0c 在 Java 中字符串属于对象 xff0c Java 提供了 String

  • 3：Throwable-Java API 实战

    目录 1 异常的介绍2 异常举例以及解决常见错误bug方案3 RuntimeException4 trycatch作用 xff0c 闲扯淡诱骗毕业设计5 NullPointerException空指针异常6 throws7 throws和t

  • 4：File-Java API 实战

    目录 1 引言2 绝对路径和相对路径 xff1f 先学送快递吧 xff01 3 绝对路径4 相对路径5 File类6 Linux上的绝对路径有所不同 1 引言 文件要区别绝对路径和相对路径 xff0c 在Win系统中的文件路径和Linux

  • 5：IO Stream-Java API 实战

    目录 1 相对论和IO流之说2 汉语文学理解IO流3 图解IO流4 俩亲爹 xff1a InputStream和OutPutStream5 FileInputStream字节流读取文件6 FileOutPutStream字节流写入文件7 b

  • 6：CharSet-Java API 实战

    目录 1 阶段2 字符集编码吹X3 转换字符编码 1 阶段 Java NIO File Java NIO中的Files类 xff08 java nio file Files xff09 提供了多种操作文件系统中文件的方法 Java File

  • 7：Multithreading-Java API 实战

    目录 1 问题的提出2 核心数 进程 线程3 进程和线程的区别以及对应应用4 多线程程序含义 多线程的作用5 多线程的执行过程6 Runnable7 简化操作以及线程名8 抢购鞋 多线程案例9 后台 守护进程的提出10 匿名内部类创建多线程

  • 8：Java Conllections FrameWork-Java API 实战

    目录 1 原生数组带来的问题 xff0c 抛出问题2 Conllections家族3 黑帮的帮规4 ArrayList第一讲5 ArrayList第二讲6 ArrayList第三讲7 Linked链表8 LinkedList一带而过9 提醒

  • 9：JDBC-Java API 实战

    目录 1 说明2 JDBC的由来以及定义3 JDBC体验 xff0c statement executeQuery 查询4 整理和释放5 封装JDBCUtils6 增删改 executeUpdate 7 字符编码问题8 PreparedSt

  • 10：Java人脸识别认证-Java API 实战

    目录 1 提出问题 xff0c 引入SDK的概念2 选择平台3 SDK下载和文档说明4 人脸检测5 人脸对比6 建议和结束语 1 提出问题 xff0c 引入SDK的概念 什么是SDK xff1f 我们并不具备开发人脸识别的能力 xff0c

  • 个人学习笔记附Markdown格式下载

    B S方向 文章链接 xff1a https blog csdn net qq 46207024 article details 114378676 spm 61 1001 2014 3001 5502 下载链接 xff1a https d

  • Ubuntu/Linux 访问 Windows 共享文件夹

    文章目录 Ubuntu Linux 访问 Windows 共享文件夹SMB 协议安装 samba 客户端访问共享文件夹参考资料 Ubuntu Linux 访问 Windows 共享文件夹 SMB 协议 Linux 操作系统与 Windows

  • Java 序列化与反序列化

    目录 一 说明二 理解三 实现1 实现接口2 序列化方法3 反序列化方法 一 说明 序列化与反序列化是什么 序列化 xff1a 将Java对象表示为一个字节序列 xff0c 存储对象数据到文件中 xff0c 可用于网络传输 反序列化 xff

  • JavaMail 使用POP3/SMTP服务发送QQ邮件

    目录 一 说明二 理解三 实现1 导入jar包2 用户认证3 发送邮件创建步骤简单的Email带HTML的E mail带图片的Email包含附件的邮件 一 说明 邮件服务器 为用户提供接收邮件的功能 xff0c 有发邮件的SMTP服务器 x

  • Java多线程 Callable和Future

    目录 一 说明二 理解三 实现1 实现接口2 执行线程 一 说明 Java 提供了三种创建线程的方法 实现 Runnable接口继承 Thread类本身通过 Callable和 Future 创建线程 Callable和Future的引入

  • Java多线程 Future和FutureTask的区别

    目录 一 说明二 理解三 实现1 实现接口2 使用Future3 使用FutureTask 一 说明 Future和FutureTask的关系 Future 是一个接口 xff0c 无法直接创建对象 xff0c 需配合线程池使用 submi

  • Java多线程 CompletionService和ExecutorCompletionService

    目录 一 说明二 理解三 实现1 使用Future2 使用ExecutorCompletionService3 take 方法4 poll 方法5 poll long timeout TimeUnit unit 方法 一 说明 Future

  • Java多线程 线程池Executor框架

    目录 一 说明二 理解ExecutorExecutorServiceExecutors 三 实现1 newSingleThreadExecutor2 newFixedThreadPool3 newCachedThreadPool4 newS

  • Java多线程 ThreadPoolExecutor自定义线程池

    目录 一 说明二 理解三 实现1 SynchronousQueue2 ArrayBlockingQueue3 LinkedBlockingQueue 一 说明 ThreadPoolExecutor Java提供的线程池Executor框架相

  • Java多线程 ThreadPoolExecutor-RejectedExecutionHandler拒绝执行策略

    目录 一 说明二 理解三 实现1 AbortPolicy2 DiscardPolicy3 DiscardOldestPolicy4 CallerRunsPolicy5 自定义拒绝执行策略 一 说明 RejectedExecutionHand

  • Java多线程 关闭线程池 shutdown() 、shutdownNow()、awaitTermination()

    目录 一 说明二 理解三 实现1 shutdown 2 shutdownNow 3 awaitTermination 一 说明 ThreadPoolExecutor 继承 Executor 接口它有多个构造方法来实现自定义创建线程池 xff

热门标签