JAVA线程池ThreadPoolExecutor

最新推荐文章于 2024-05-03 17:39:16 发布
转载 最新推荐文章于 2024-05-03 17:39:16 发布 · 616 阅读 · 0

本文介绍了Java中的线程池概念及其使用方式，包括线程池的主要参数解释、构造方法、预定义线程池服务以及线程池的工作原理。此外，还提供了一个简单的线程池示例程序。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转自：http://www.micmiu.com/lang/java/java-threadpoolexecutor/


作者: Michael日期: 2012 年 2 月 21 日 发表评论 (0) 查看评论

java.util.concurrent.ThreadPoolExecutor相关基础介绍和使用示例。

[ 一 ]、常用线程池

最常用构造方法为：

1ThreadPoolExecutor(int corePoolSize,
2                   int maximumPoolSize,
3                   long keepAliveTime,
4                   TimeUnit unit,
5                   BlockingQueue<Runnable> workQueue,
6                   RejectedExecutionHandler handler)

JDK自带的配置好的线程池：

1// 固定工作线程数量的线程池
2ExecutorService executorService1 = Executors.newFixedThreadPool(3);
3 
4// 一个可缓存的线程池
5ExecutorService executorService2 = Executors.newCachedThreadPool();
6 
7// 单线程化的Executor
8ExecutorService executorService3 = Executors.newSingleThreadExecutor();
9 
10// 支持定时的以及周期性的任务执行
11ExecutorService executorService4 = Executors.newScheduledThreadPool(3);

这些预定义好的线程池服务也是基于ThreadPoolExecutor配置的，所以我们应该从最基本的参数着手了解，如下：

参数详细说明：
[ 1 ]、corePoolSize： 线程池维护线程的最少数量
[ 2 ]、maximumPoolSize：线程池维护线程的最大数量
[ 3 ]、keepAliveTime： 线程池维护线程所允许的空闲时间
[ 4 ]、unit： 线程池维护线程所允许的空闲时间的单位，unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：

  • NANOSECONDS
  • MICROSECONDS
  • MILLISECONDS
  • SECONDS

[ 5]、workQueue： 线程池所使用的缓冲队列，常用的是：java.util.concurrent.ArrayBlockingQueue
[ 6 ]、handler： 线程池对拒绝任务的处理策略，有四个选择如下：

  • ThreadPoolExecutor.AbortPolicy()：抛出java.util.concurrent.RejectedExecutionException异常
  • ThreadPoolExecutor.CallerRunsPolicy()：重试添加当前的任务，他会自动重复调用execute()方法
  • ThreadPoolExecutor.DiscardOldestPolicy()：抛弃旧的任务
  • ThreadPoolExecutor.DiscardPolicy()：抛弃当前的任务

[ 二 ]、详细说明

[ 1 ]、当一个任务通过execute(Runnable)方法欲添加到线程池时：

  • 如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
  • 如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
  • 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
  • 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于
    maximumPoolSize，那么通过
    handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程
    maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
  • 当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

[ 2 ]、核心和最大池大小

ThreadPoolExecutor 将根据 corePoolSize（参见 getCorePoolSize()）和 maximumPoolSize（参见 getMaximumPoolSize()）设置的边界自动调整池大小。当新任务在方法 execute(java.lang.Runnable) 中提交时，如果运行的线程少于 corePoolSize，则创建新线程来处理请求，即使其他辅助线程是空闲的。如果运行的线程多于 corePoolSize 而少于 maximumPoolSize，则仅当队列满时才创建新线程。如果设置的 corePoolSize 和maximumPoolSize 相同，则创建了固定大小的线程池。如果将 maximumPoolSize 设置为基本的无界值（如 Integer.MAX_VALUE），则允许池适应任意数量的并发任务。在大多数情况下，核心和最大池大小仅基于构造来设置，不过也可以使用 setCorePoolSize(int) 和setMaximumPoolSize(int) 进行动态更改。

[ 3 ]、排队及策略

所有 BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互：

  • 如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队。
  • 如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。
  • 如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝。

排队有三种通用策略：

  • 直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集合时出现锁定。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
  • 无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙的情况下将新任务加入队列。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
  • 有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。

[ 4 ]、拒绝任务的处理策略 （这个和参数handler设置相关）

当 Executor 已经关闭，并且 Executor 将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法 execute(java.lang.Runnable) 中提交的新任务将被拒绝。在以上两种情况下，execute 方法都将调用其 RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略：

  • 在默认的 ThreadPoolExecutor.AbortPolicy 中，处理程序遭到拒绝将抛出运行时 RejectedExecutionException。
  • 在 ThreadPoolExecutor.CallerRunsPolicy 中，线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
  • 在 ThreadPoolExecutor.DiscardPolicy 中，不能执行的任务将被删除。
  • 在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。
  • 定义和使用其他种类的 RejectedExecutionHandler 类也是可能的，但这样做需要非常小心，尤其是当策略仅用于特定容量或排队策略时。

[ 三 ]、简单示例

JavaThreadPool.java

1package michael.thread.pool;
2 
3import java.util.Date;
4import java.util.concurrent.ArrayBlockingQueue;
5import java.util.concurrent.ThreadPoolExecutor;
6import java.util.concurrent.TimeUnit;
7 
8/**
9 * @see http://www.micmiu.com
10 * @author michael sjsky007@gmail.com
11 */
12public class JavaThreadPool {
13 
14    /**
15     * @param args
16     */
17    public static void main(String[] args) {
18 
19        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 5, 60,
20                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10),
21                new ThreadPoolExecutor.CallerRunsPolicy());
22        for (int i = 0; i < 10; i++) {
23            System.out.println("add job_" + i + " at:" + new Date());
24            SimplePrintJob job = new SimplePrintJob("job_" + i);
25            threadPool.execute(job);
26        }
27        System.out.println("execute all job");
28        threadPool.shutdown();
29        System.out.println("main program end-----------");
30    }
31 
32}

SimplePrintJob.java

1package michael.thread.pool;
2 
3import java.util.Random;
4 
5 
6/**
7 * @see http://www.micmiu.com
8 * @author michael sjsky007@gmail.com
9 */
10public class SimplePrintJob implements Runnable {
11 
12    private String jobName;
13 
14    /**
15     * @param jobName
16     */
17    public SimplePrintJob(String jobName) {
18        this.jobName = jobName;
19    }
20 
21    /**
22     * @see java.lang.Runnable#run()
23     */
24    public void run() {
25        System.out.println("[ " + jobName + " ] start...");
26        int random = 0;
27        try {
28            Random r = new Random();
29            random = r.nextInt(10);
30            Thread.sleep(random * 1000L);
31        } catch (Exception e) {
32            e.printStackTrace();
33        }
34        System.out.println("[ " + jobName + " ] end with sleep:" + random);
35    }
36}

运行结果如下：

1add job_0 at:Sun Jun 19 00:52:02 CST 2011
2add job_1 at:Sun Jun 19 00:52:02 CST 2011
3add job_2 at:Sun Jun 19 00:52:02 CST 2011
4[ job_0 ] start...
5add job_3 at:Sun Jun 19 00:52:02 CST 2011
6add job_4 at:Sun Jun 19 00:52:02 CST 2011
7add job_5 at:Sun Jun 19 00:52:02 CST 2011
8add job_6 at:Sun Jun 19 00:52:02 CST 2011
9add job_7 at:Sun Jun 19 00:52:02 CST 2011
10add job_8 at:Sun Jun 19 00:52:02 CST 2011
11add job_9 at:Sun Jun 19 00:52:02 CST 2011
12execute all job
13[ job_2 ] start...
14[ job_0 ] end with sleep:0
15[ job_3 ] start...
16[ job_2 ] end with sleep:0
17[ job_4 ] start...
18main program end-----------
19[ job_1 ] start...
20[ job_4 ] end with sleep:1
21[ job_5 ] start...
22[ job_5 ] end with sleep:6
23[ job_6 ] start...
24[ job_1 ] end with sleep:7
25[ job_7 ] start...
26[ job_3 ] end with sleep:8
27[ job_8 ] start...
28[ job_6 ] end with sleep:4
29[ job_9 ] start...
30[ job_7 ] end with sleep:6
31[ job_8 ] end with sleep:7
32[ job_9 ] end with sleep:5

我们可以自己更改 RejectedExecutionHandler handler这个参数，来观察运行结果会有什么不同。


Java线程池ThreadPoolExecutor背后的秘密与实践
张彦峰的博客
05-12 170万+
本文深入分析了Java线程池ThreadPoolExecutor的工作原理、核心参数以及配置策略。通过详细讲解线程池的创建、任务调度和线程管理机制，帮助开发者理解如何高效使用线程池来处理并发任务。文章还探讨了常见的性能瓶颈和优化方法，如合理配置线程池参数、选择适当的拒绝策略等，旨在提升应用的并发处理能力和稳定性。最终，读者将能够根据不同场景灵活调整线程池配置，从而有效提升系统性能。
Java线程池 ThreadPoolExecutor 业务线程池
岸河世界
12-31 1892
1.什么是业务线程池？ 在业务开发中，用来处理业务的线程池。 2.为什么需要业务线程池？ 大多数同学都是做业务开发的，很多业务的操作并非要求一定是同步的。例如，对于一系列连续的业务逻辑处理，很多都是数据的组装，拼接，查询，或者将数据同步给各个下层业务（对事务性没有严格要求）；或者对数据的批量操作；这些都可以是异步的。通常业务项目使用的都是的servlet框架，都是使用一个线程进行业务逻辑处理，这种模型是通用的，但不一定是最佳的，不一定是最适合的。需要我们业务开发者根据实际的业务场景去灵活应用，达到最快的响.
JAVA ThreadPoolExecutor详解
wurensen的专栏
10-15 1539
JAVA ThreadPoolExecutor详解 基础     在我看来，java比C++的一个大好处就是提供了对多线程的支持（C++只有多线程的库，语言本身不包含线程的概念）。而其中我最爱用的就是ThreadPoolExecutor这个类，它实现了一个非常棒的thread pool。 thread pool一般被用来解决两个问题：当处理大量的同步task的时候，它能够避免
java ThreadPoolExecutor
TimerBin的博客
01-19 205
java ThreadPoolExecutor 学习笔记 /**   * @param corePoolSize   *        线程池中保持的线程数量   * @param maximumPoolSize   *        线程池最大可开启线程数   * @param keepAliveTime   *        当线程池中的线程总量大于保持的线程数量时， *...
java ThreadPoolExecutor
zhuangyalei的专栏
04-29 982
ThreadPoolExecutor机制  一、概述  1、ThreadPoolExecutor作为java.util.concurrent包对外提供基础实现，以内部线程池的形式对外提供管理任务执行，线程调度，线程池管理等等服务；  2、Executors方法提供的线程服务，都是通过参数设置来实现不同的线程池机制。  3、先来了解其线程池管理的机制，有助于正确使用，避免错误使用导致严重故障
java-ThreadPoolExecutor
test的博客
08-22 503
Java并发编程：线程池的使用 　　在前面的文章中，我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 　　如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 　　那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？ 　　...
Java线程池ThreadPoolExecutor原理及使用实例
08-19
Java线程池ThreadPoolExecutor原理及使用实例 Java线程池ThreadPoolExecutor是Java并发编程中的一种基本机制，主要用于管理和执行任务的线程池。下面对其原理和使用实例进行详细介绍。 线程池概述 线程池是一个...
java线程池ThreadPoolExecutor类使用详解.docx
06-21
在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了...
Java线程池ThreadPoolExecutor极简教程
Trouvailless的博客
05-27 450
ThreadPoolExecutor 简介 ThreadPoolExecutor 是 java.util.concurrent 包下的一个类，在jdk1.5版本引入，帮助开发人员管理线程并方便地执行并行任务。 通俗来说，ThreadPoolExecutor 的作用是生产和管理线程池的，可以通过调用其 execute 方法和 submit 方法执行多线程任务。 ThreadPoolExecutor 使用 创建执行器 ExecutorService 对象和 ThreadPoolExecutor 的关系
Java多线程（8）线程池
haiyanghan的博客
11-11 210
上一篇：Java多线程（7）手写线程池 JDK线程池 ThreadPoolExecutor 多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力，但频繁的创建线程的开销是很大的，那么如何来减少这部分的开销了，那么就要考虑使用线程池了。线程池就是一个线程的容器，每次只执行额定数量的线程，线程池就是用来管理这些额定数量的线程。 一. 线程池状态 ...
java中的线程池ThreadPoolExecutor
ab1024249403的博客
08-09 183
java中的线程池什么是线程池JDK对线程池的支持线程池工厂Executors计划任务ScheduledExecutorService核心线程池的内部实现线程池常用方法 什么是线程池 虽然与进程相比，线程是一种轻量级的工具，但其创建和关闭仍然需要花费时间。当线程数量过大时，反而会耗尽CPU和内存资源，大量的线程回收也会给GC带来很大的压力，延长GC的停顿时间。 线程池中，总有那么几个活跃线程。当你需要使用线程时，可以从池子中随便拿一个空闲线程，当完成工作时，并不着急关闭线程，而是将这个线程退回到池子中，方
Java ThreadPoolExecutor 简单剖析
ZhangXL的专栏
03-22 379
一、ThreadPoolExecutor概述1.简介ThreadPoolExecutor继承自AbstractExecutorService。线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行集合任务时使用的线程）的方法。每个 ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数
Java线程池ThreadPoolExecutor及常见的4种线程池
weixin_43554317的博客
10-19 1188
我们有两种常见的创建线程的方法，一种是继承Thread类，一种是实现Runnable的接口，Thread类其实也是实现了Runnable接口。但是我们创建这两种线程在运行结束后都会被虚拟机销毁，如果线程数量多的话，频繁的创建和销毁线程会大大浪费时间和效率，更重要的是浪费内存，因为正常来说线程执行完毕后死亡，线程对象变成垃圾！那么有没有一种方法能让线程运行完后不立即销毁，而是让线程重复使用，继续执行...
Java线程池ThreadPoolExecutor详解（一篇就够了）
最新发布
好好学java
05-03 7009
Executor框架主要由三部分组成，任务任务的执行者执行结果，ThreadPoolExecutor和ScheduledThreadPoolExecutor的设计思想也是将这三个关键要素进行了解耦，将任务的提交和执行分离。任务在和中任务是指实现了Runnable接口和Callable接口的类，中将任务转换成FutureTask类，中任务被转换成类，该类继承FutureTask，并重写了run方法，实现了延时执行任务和周期性执行任务。任务的执行者包括任务执行机制的核心接口Executor，以及继承自。
Java：ThreadPoolExecutor解析
demon7552003的小本本
06-13 327
目录 功能介绍 线程池相关类图 源码解析 基本概念 字段域 常量 线程构造重要字段 线程控制重要字段 方法 执行任务 ThreadPoolExecutor的关闭 功能介绍 线程池，顾名思义一个线程的池子，池子里存放了很多可以复用的线程，如果不用线程池类似的容器，每当我们需要创建新的线程时都需要去new Thread（），用完之后就被回收了，线程的启动回收都需要用户态...
Java ThreadPoolExecutor详解
weixin_45032957的博客
02-22 233
如何让线程不被销毁 文章开头说到，线程在执行完毕之后会被操作系统回收销毁，那么线程池时如何保障线程不被销毁？首先看一个测试用例： public static void testThreadState() { Thread thread = new Thread(() -> System.out.println(“Hello world”)); // 创建一个线程 System.out.println(thread.getState()); // 此时线程的状态为NEW thread.start();
java线程池ThreadPoolExecutor
08-03
Java线程池ThreadPoolExecutor是Java中的核心线程池实现类。它是通过使用ThreadPoolExecutor来创建和管理线程池的。在Spring框架中，使用ThreadPoolTaskExecutor来管理线程池，它是对ThreadPoolExecutor进行封装，使...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值