关于Java线程池ThreadPoolExecutor相关介绍

阿布～

已于 2022-04-14 21:28:03 修改

阅读量1k

点赞数 29

分类专栏：笔记多线程 Java 文章标签： java 多线程线程池

于 2022-04-14 21:24:06 首次发布

本文链接：https://blog.csdn.net/weixin_46448719/article/details/124145234

版权

笔记同时被 3 个专栏收录

22 篇文章 0 订阅

订阅专栏

Java

13 篇文章 0 订阅

订阅专栏

多线程

11 篇文章 0 订阅

订阅专栏

Java 并发包中线程池 ThreadPoolExecutor

为什么要使用线程池？
线程池类图相关介绍
线程池的创建方式

为什么要使用线程池？

线程池主要解决两个问题：一是当执行大量异步任务时线程池能够提供较好的性能。在不使用线程池时，每当需要执行异步任务时直接 new 一个线程来运行，而线程的创建和销毁是需要开销的。线程池里面的线程是可以服用的，不需要每次执行异步任务时都重新创建和销毁线程等。每个 ThreadPoolExecutor 也保留了一些基本的统计数据，比如当前线程池完成的任务数目等。

另外，线程池也提供了许多可调参数和可扩展性接口，以满足不同情境的需要，我们可以使用更方便的 Executors 的工厂方法，比如 newCachedThreadPool（线程池线程个数最多可达 Integer.MAX_VALUE，线程自动回收）、newFixedThreadPool（股东大小的线程池）和 newSingleThreadExecutor（单个线程）等来创建线程池。

线程池类图相关介绍

Executors 其实是个工具类，里面提供了好多静态方法，这些方法根据用户选择返回不同的线程池实例。ThreadPoolExecutor 继承了 AbstractExecutorService，成员变量 ctr 是一个 Integer 的原子变量，用来记录线程池状态和线程池中线程个数。

这里假设 Integer 类型是32位二进制表示，则其中高 3 位用来表示线程池状态，后面 29 位用来记录线程池线程个数。


//（ 高3位）用来表示线程池状态，（低29位）用来表示线程个数
// 默认是RUNNING状态，线程个数为0
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)) ; 
// 线程个数掩码位数，并不是所有平台的int类型都是32位的，所以准确地说，是具体平台下Integer二进制位数-3后的剩余位数所表示的数才是线程的个数
private static final int COUNT_BITS = Integer.SIZE - 3 ; 
// 线程最大个数（低29位） 00011111111111111111111111111111 
private static final int CAPACITY = (1 << COUNT_BITS) - 1 ;

线程池状态:


//（高3位） : 11100000000000000000000000000000 
private static final int RUNNING   = -1 << COUNT_BITS; 
// (高3主） : 00000000000000000000000000000000 
private static final int SHUTDOWN   = 0 << COUNT_BITS ; 
//（高3位） : 00100000000000000000000000000000 
private static final int STOP       = 1 < COUNT BITS ; 
//（高3位） : 01000000000000000000000000000000 
private static final int TIDYING    = 2 < COUNT BITS; 
//（高3位） : 01100000000000000000000000000000 
private static final int TERMINATED = 3 < COUNT_BITS;
// 获取高3位（运行状态）
private static int runStateOf(int c) { return c & ~CAPACITY ; }
// 获取低29位（线程个数）
private static int workerCountOf(int c) { return c & CAPACITY ; }
// 计算ctl新值（线程状态与线程个数）
private static int ctlOf (int rs, int we) { return rs | we; }

线程池状态含义如下。

RUNNING： 接受新任务并且处理阻塞队列里的任务。
SHUTDOWN： 拒绝新任务但是处理阻塞队列里的任务。
TIDYING： 所有任务都执行完（包含阻塞队列里面的任务）后当前线程池数为 0，将要调用terminated方法。
TERMINATED： 终止状态。terminated 方法调用完成以后的状态。
RUNNING -> SHUTDOWN: 显式调用 shutdown() 方法，或者隐式调用了 finalize() 方法里面的 shutdown() 方法。
RUNNING 或 SHUTDOWN -> STOP： 显式调用 shutdownNow() 方法时。
SHUTDOWN -> TIDYING： 当线程池任务队列都为空时。
STOP -> TIDYING： 当线程池为空时。
TIDYING -> TERMINATED： 当 terminated() hook 方法执行完成时。

线程池参数如下。

corePoolSize： 线程池核心线程个数。
workQueue： 用于保存等待执行的任务阻塞队列，比如基于数组的有界 ArrayBlockingQueue、基于链表的无界 LinkedBlockingQueue、最多只有一个元素的同步队列 SynchronousQueue 及优先级队列 PriorityBlockingQueue 等。
maximunPoolSize： 线程池最大线程数量。
ThreadFactory： 创建线程工厂。
RejectedExecutionHandler： 饱和策略，当队列满并且线程个数达到 maximunPoolSize 后采取的策略，比如 AbortPolicy（抛出异常）、CallerRunsPolicy（使用调用者所在线程来运行任务）、DiscardOldestPolicy（调用 poll 丢弃一个任务，执行当前任务）及 DiscardPolicy（默默丢弃，不抛出异常）
keeyAliveTime： 存活时间。如果当前线程池中的线程数量比核心线程数量多，并且是闲置状态，则这些闲置的线程能存活的最大时间。
TimeUnit： 存活时间的时间单位。

线程池的创建方式

线程池的创建方式总共包含以下 7 种，（其中 6 钟是通过 Executors 自动创建的，1 种是通过 ThreadPoolExecutor 手动创建的。）
在这里插入图片描述

1. newFixedThreadPool 创建固定线程数量的线程池

newFixedThreadPool： 创建一个核心线程个数和最大线程个数都为 nThreads 的线程池，并且阻塞队列的长度为 Integer.MAX_VALUE。keeyAliveTime=0 说明只要线程个数比核心线程个数多并且当前空闲则回收。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 创建一个固定大小的线程池
 */
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        // 创建一个线程个数为5的固定大小的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名称：" + Thread.currentThread().getName());
                }
            });
            
// 使用线程池执行任务2
        for (int i = 0; i < 10; i++) {
            // 给线程池添加任务
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名称：" + Thread.currentThread().getName());
                }
            });
        }
    }
}

执行结果：
在这里插入图片描述
从以上代码我们可以看到，使用Executors.newFixedThreadPool() 方法，传递一个整型参数，此时系统就会自动帮我们创建固定数量的线程，此处我们创建了五个线程，通过 JVM 我们也可以观察到我们创建的线程池中包含有五个新创建好等待工作的线程，当我们有工作任务时，就可以直接从线程池中拿出线程去用。
threadPool.submit() 和threadPool.execute() 的区别

在这里插入图片描述
使用 submit 它可以执行有返回值的任务或者是无返回值的任务；而 execute 只能执行不带返回值的任务。

线程池有返回值实现：

import java.util.Random;
import java.util.concurrent.*;

/**
 * 演示有返回值的线程池
 */
public class ThreadPoolDemo2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建一个线程个数为5的固定大小的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        Future<Integer> result = threadPool.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int num = new Random().nextInt(10);
                System.out.println("生成随机数：" + num);
                return num;
            }
        });
        System.out.println("得到线程池返回结果：" + result.get());
    }
}

线程池中的工厂

我们创建一个线程池，无疑是要创建很多线程的，那线程池在创建线程的时候，也是需要给线程有一个明确的标准的，需要给线程提供相关的参数，那么这个给线程池创建添加线程的过程，就是需要线程工厂来完成的。

我们可以看一下 JDK 给我们提供的默认线程池的定义方式：
在这里插入图片描述
如果我们自己不设置线程工厂，线程池就会使用默认的线程工厂来创建线程。

下面我们来自己设置一个线程工厂：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

import static java.lang.Thread.MAX_PRIORITY;

public class ThreadPoolDemo3_线程工厂演示 {
    public static void main(String[] args) {
        // 1. 创建线程工厂
        ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                // 一定要把Runnable设置给新创建的线程
                Thread thread = new Thread(r);
                // 设置线程的命名规则
                thread.setName("->" + r.hashCode());
                // 设置线程优先级
                thread.setPriority(MAX_PRIORITY);
                return thread;
            }
        };
        ExecutorService service = Executors.newFixedThreadPool(5,factory);
        for (int i = 0; i < 5; i++) {
            service.submit(new Runnable() {
                @Override
                public void run() {
                    // 任务来了
                    System.out.println("我的" + Thread.currentThread().getName()+"号线程开始执行任务");
                }
            });
        }
    }
}

执行效果：
在这里插入图片描述
我们通过自己定义线程工厂来创建线程，线程工厂提供的功能有：

设置（线程池中的）线程的命名规则
设置线程的优先级
设置线程的分组
设置线程类型（用户线程&守护线程）、

2. newCachedThreadPool 带缓存的线程池

创建一个按需创建的线程池，初始线程个数为 0，最多线程个数为 Integer.MAX_VALUE，并且阻塞队列为同步队列。keeyAliveTime=60 说明只要当前线程在 60s 内空闲则回收。这个类型的特殊之处在，加入同步队列的任务会被马上执行，同步队列里面最多只有一个任务。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池用法2：带缓存的线程池
 */
public class ThreadPoolDemo4 {
    public static void main(String[] args) {
        // 创建带缓存的线程池
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            service.submit(() -> {
                System.out.println("i："+ finalI +"|线程名称"+Thread.currentThread().getName());
            });
        }
    }
}

运行结果：
在这里插入图片描述

因为只要不结束这个线程池任务销毁线程池，在线程池中创建的线程是不会在执行一次任务结束时自动销毁的，而是会缓存起来，等待其他的任务加入以便再次复用线程。带缓存的线程池比较适用的场景是突发的带有大量任务的情况下使用这种方式会比较合适，因为它可以根据任务量来帮你分配线程数并且对资源的分配也相对比较合适。

3. newScheduledThreadPool 执行定时任务的线程池

这个执行定时任务的线程池我们主要了解 schedule 方法的三个参数的意义就可以掌握这个方法，我们进入这个方法内部：
在这里插入图片描述
schedule方法：延迟执行一次定时任务；
long delay 参数：延迟多久进行执行；
TimtUnit unit 参数：对参数2 的时间单位描述。

事例：

import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 创建执行定时任务的线程池
 */
public class ThreadPoolDemo5 {
    public static void main(String[] args) {
        // 创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务的时间：" + LocalDateTime.now());
        // 执行定时任务
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务：" + LocalDateTime.now());
            }
        },3, TimeUnit.SECONDS);
    }
}

执行结果：
在这里插入图片描述
成功执行了一次定时任务。接下来我们看如何执行多次定时任务及两个执行多次任务方法的区别。

scheduleAtFixedRate 以上一次任务的开始时间作为开始时间计算延迟任务的执行时间

        // 2s 之后开始执行定时任务，定时任务每隔4s 执行一次
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务：" + LocalDateTime.now());
            }
        },2,4,TimeUnit.SECONDS);

在这里插入图片描述
scheduleAtFixedRate注意事项：

如果执行任务的时间大于设定的任务执行时间间隔，比如，我们的任务间隔参数设置为 2s 但是在任务中含有一个 sleep(3000) 的休眠时间。那么此方法会以任务执行的时间为定时任务的间隔周期来执行。也就是说，哪个值大就是用哪个值作为定时任务的执行周期。

scheduleWithFixedRate 以上一次任务的结束时间作为开始时间计算延迟任务的执行时间

演示这个方法，以下我们设置了一个时间间隔为 4s 的线程池，但是在每一个任务中我们会有一个 sleep(1000) 休眠 1s 的任务。

        service.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务：" + LocalDateTime.now());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },2,4,TimeUnit.SECONDS);

执行结果：
在这里插入图片描述

4. newSingleThreadScheduledExecutor 执行定时任务的单线程线程池

这种线程创建方式相当于第三种创建方式创建单个线程。

import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolDemo6 {
    public static void main(String[] args) {
        // 创建执行定时任务的单线程线程池
        ScheduledExecutorService service =
                Executors.newSingleThreadScheduledExecutor();
        System.out.println("添加任务时间" + LocalDateTime.now());
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务时间：" + LocalDateTime.now());
            }
        },2, TimeUnit.SECONDS);
    }
}

执行结果：
在这里插入图片描述

5. newSingleThreadExecutor 单线程线程池

创建一个核心线程个数和最大线程个数都为 1 的线程池，并且阻塞队列长度为 Integer.MAX_VALUE。keeyAliveTime=0 说明只要线程个数比核心线程个数多并且当前空闲则回收。

import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo7 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(LocalDateTime.now() +"-线程名" + Thread.currentThread().getName());
                }
            });
        }
    }
}

执行结果：
在这里插入图片描述
从结果可以看到，单线程的线程池就只会产生一个线程所有任务都使用这一个线程执行。

为什么不直接使用线程，单线程的线程池有什么意义？

虽然是单线程的线程池，但是它不会频繁的创建和销毁线程，只要线程池没有被结束销毁，就可以一直复用这个线程。
单线程的线程池也是提供了任务队列和拒绝策略的，当这个线程在执行其他任务时，新加进来的任务会被排队放在任务队列中等待被执行，当任务队列也都放满的时候，线程池就会友好的执行拒绝策略。
所以说，如果使用了线程池，无论有多少的任务，哪怕线程池只有一个线程，也都会有效的将这些任务都完成执行的。但是线程就不行了。

单线程线程池任务队列保证先进先出原则

任务队列底层实现是我使用了：LinkedBlockingQueue<>()
在这里插入图片描述

    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            service.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("任务："+ finalI +"-线程名" + Thread.currentThread().getName());
                }
            });
        }
    }

执行结果：
在这里插入图片描述

6. newWorkStealingPool 根据当前CPU生成线程池

这种线程池的创建方式是 JDK1.8 才提供的，它是会根据当前的 CPU 资源，根据你的运行程序的电脑配置，来生成相应的线程个数的。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo8 {
    public static void main(String[] args) {
        //根据当前设备的配置自动生成线程池
        ExecutorService service = Executors.newWorkStealingPool();

        for (int i = 0; i < 100; i++) {
            service.submit(() -> {
                System.out.println("线程名" + Thread.currentThread().getName());
            });
        }
        while (!service.isTerminated()) {
        }
    }
}

执行结果：
在这里插入图片描述
我们启动了100个任务，从运行结果找出最大的线程数，发现线程池为我们创建了 0-7 共 8 个线程，这是因为我所使用的设备配置 CPU 是八核的，newWorkStealingPool 这种创建方式也就根据设备配置提供了相应的线程数。

7. ThreadPoolExecutor 手动方式创建线程池

Executors 自动创建线程池可能存在的问题

以下是阿里巴巴开发手册里面的规定：
在这里插入图片描述
也就是说，使用自动创建线程池的方式，在海量任务量的业务处理中，因为这种自动创建方式任务队列的大小是 Integer.MAX_VALUE 是无限大的，那么就可能存在资源耗尽的风险，在程序中就是可能会导致内存溢出。而我们选择手动创建线程池就可以根据自己的内存情况手动设置任务队列和拒绝策略的参数，以避免内存溢出或程序崩溃。

ThreadPoolExecutor 使用

参数种类
参数解释
代码示例

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolDemo9 {
    public static void main(String[] args) {
        ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                return thread;
            }
        };
        // 手动方式创建线程池
        ThreadPoolExecutor executor =
                new ThreadPoolExecutor(5,10,10, TimeUnit.SECONDS,
                        new LinkedBlockingQueue<>(100),factory,
                        new ThreadPoolExecutor.DiscardPolicy());
        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                System.out.println("线程名称：" + Thread.currentThread().getName());
            });
        }
    }
}

执行效果：
在这里插入图片描述

以上代码，创建了一个含有 5 个核心线程，最大线程数为 10 ，闲置线程最大存活时间为 10s 的线程池。需要注意的是，我们对于参数 workQueue ，一定要给任务队列设置大小，这是手动创建线程池最大的不同于自动创建线程池的规范。

线程池参数说明

corePoolSize： 线程池核心线程个数。
workQueue： 用于保存等待执行的任务阻塞队列，比如基于数组的有界 ArrayBlockingQueue、基于链表的无界 LinkedBlockingQueue、最多只有一个元素的同步队列 SynchronousQueue 及优先级队列 PriorityBlockingQueue 等。
maximunPoolSize： 线程池最大线程数量。
ThreadFactory： 创建线程工厂。
RejectedExecutionHandler： 饱和策略，当队列满并且线程个数达到 maximunPoolSize 后采取的策略，比如 AbortPolicy（抛出异常）、CallerRunsPolicy（使用调用者所在线程来运行任务）、DiscardOldestPolicy（调用 poll 丢弃一个任务，执行当前任务）及 DiscardPolicy（默默丢弃，不抛出异常）
keeyAliveTime： 存活时间。如果当前线程池中的线程数量比核心线程数量多，并且是闲置状态，则这些闲置的线程能存活的最大时间。
TimeUnit： 存活时间的时间单位。

线程池执行流程+线程池重要执行节点

在这里插入图片描述
这里有一个面试问题：

为什么在线程池执行流程中，当任务数大于核心线程数时，是先判断阻塞队列是否已满，如果阻塞队列没有满是先将任务放进阻塞队列等待执行，而不是直接判断当前线程数是否小于最大线程数去直接创建线程执行的。

我们需要了解的是：线程池的执行机制是会延迟创建线程的，那么为什么会选择延迟创建，这是和线程池资源利用的策略有关系的，也就是并不是在创建线程池时候直接创建好核心线程数量的线程的，而是在有任务来了之后，线程工厂才会根据任务需要去创建线程，而先进行任务队列的判断也就是为了保证资源利用的最大化和开销的最小化。

线程池重要执行节点：

当任务来了之后，判断线程池中实际线程数是否小于核心线程数，如果小于就直接创建线程并执行任务。
当实际线程数大于核心线程数，他会判断任务队列是否已满，如果未满直接将任务存放队列即可。
判断线程池的实际线程数是否大于最大线程数，如果小于最大线程数直接创建线程执行任务；实际线程

线程池拒绝策略（4+1）

在这里插入图片描述

CallerRunsPolicy： 当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然损失较大。
AbortPolicy： 直接丢弃，当抛出拒绝执行 RejectExcutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。
DiscardPolicy： 直接丢弃，其他啥都没有
DiscardOldestPolicy： 当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入。

示例代码：

    public static void main(String[] args) {
        ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                return thread;
            }
        };
        // 手动方式创建线程池
        ThreadPoolExecutor executor =
                new ThreadPoolExecutor(2, 2, 10, TimeUnit.SECONDS,
                        new LinkedBlockingQueue<>(2), factory,
                        new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            executor.submit(() -> {
                try {
                    Thread.sleep(100 * finalI);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "——执行任务：" + finalI);
            });
        }
        // 终止线程
        executor.shutdownNow();
    }

现象：

核心线程数为 2 ，最大线程数为 2，阻塞队列容量为 2。
AbortPolicy

直接报异常。
DiscardPolicy

不报异常，但也不执行第五个任务。
DiscardOldestPolicy

忽略任务队列第一个任务不执行，执行新任务。
CallerRunsPolicy

使用调用线程池的这个线程帮助执行这个任务。
自定义拒绝策略

new ThreadPoolExecutor(2, 2, 10, TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(2), factory,
        new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 自定义的拒绝策略业务实现...
        System.out.println("我执行了自定义拒绝策略.");
        }
});

在这里插入图片描述

线程池的状态

RUNNING： 接受新任务并且处理阻塞队列里的任务。
SHUTDOWN： 拒绝新任务但是处理阻塞队列里的任务。
TIDYING： 所有任务都执行完（包含阻塞队列里面的任务）后当前线程池数为 0，将要调用terminated方法。
TERMINATED： 终止状态。terminated 方法调用完成以后的状态。
RUNNING -> SHUTDOWN: 显式调用 shutdown() 方法，或者隐式调用了 finalize() 方法里面的 shutdown() 方法。
RUNNING 或 SHUTDOWN -> STOP： 显式调用 shutdownNow() 方法时。
SHUTDOWN -> TIDYING： 当线程池任务队列都为空时。
STOP -> TIDYING： 当线程池为空时。
TIDYING -> TERMINATED： 当 terminated() hook 方法执行完成时。

shutdown VS shutdownNow

shutdown 执行时线程池终止接收新任务，并且会将任务队列中的任务处理完；
shutdownNow 执行时线程池终止接收新任务，并且会给终止执行任务队列中的任务。

阿布～

关注

29
点赞
踩
23

收藏

觉得还不错? 一键收藏
23
评论
关于Java线程池ThreadPoolExecutor相关介绍

线程池主要解决两个问题：一是当执行大量异步任务时线程池能够提供较好的性能。在不使用线程池时，每当需要执行异步任务时直接 new 一个线程来运行，而线程的创建和销毁是需要开销的。线程池里面的线程是可以服用的，不需要每次执行异步任务时都重新创建和销毁线程等。每个 ThreadPoolExecutor 也保留了一些基本的统计数据，比如当前线程池完成的任务数目等。
复制链接

扫一扫