Java 线程池ThreadPoolExecutor

最新推荐文章于 2025-11-17 01:13:33 发布
原创 最新推荐文章于 2025-11-17 01:13:33 发布 · 2.2w 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #任务 #exception #object #hashmap #string

本文详细介绍了Java线程池ThreadPoolExecutor的使用方法，包括构造函数参数解析、线程池内部工作机制及不同拒绝策略的演示。

 

Java 线程池 ThreadPoolExecutor.

 

JDK1.5 开始关于多线程加了很多特性。如：

ConcurrentHashMap: 放弃使用公用锁同步每一个方法，使用了更细化的锁机制，分离锁。对于大数据量的 HashMap 同步操作效率有了较大提升。

CopyOnWriteArrayList: 是同步 List 的一个并发替代品。其线程安全性来源于这样一个事实：只要有效的不可变对象被正确发布，那么访问它将不再需要更多的同步。在每次需要修改时它们会创建并重新发布一个信的容器拷贝，以此来实现可变性。

增加了 Callable 和 Future 。 Callable 是 runnable 的一个可选替代。我们之前用的 Runnable 是不能返回状态的，而 Callable 是可以返回状态，返回的状态保存在泛型 Future<T> 里。

JDK1.5 里面还包含了一个重要的特性就是线程池。通过查看代码可以看出主要都是由大师 Doug Lea 来完成的。本文主要介绍线程池 ThreadPoolExecutor 的使用。

 

JDK1.5 的线程池由 Executor 框架提供。 Executor 框架将处理请求任务的提交和它的执行解耦。可以制定执行策略。在线程池中执行线程可以重用已经存在的线程，而不是创建新的线程，可以在处理多请求时抵消线程创建、消亡产生的开销。如果线程池过大，会导致内存的高使用量，还可能耗尽资源。如果过小，会由于存在很多的处理器资源未工作，对吞吐量造成损失。

由于内容较多没有一一研究，只看了较常用的 ThreadPoolExecutor ，所以在这里做个介绍。 ThreadPoolExecutor 的继承关系如下。

Executor->ExecutorService->AbstractExecutorService->ThreadPoolExecutor

核心池大小 (core pool size) 、最大池的大小 (maximum pool size) 、存活时间 (keep-alive time) 共同管理着线程的创建和销毁。

线程池类为 java.util.concurrent.ThreadPoolExecutor ，常用构造方法为：

/**

* Creates a new <tt> ThreadPoolExecutor </tt> with the given initial

* parameters.

*

* @param corePoolSize the number of threads to keep in the

* pool, even if they are idle.

* @param maximumPoolSize the maximum number of threads to allow in the

* pool.

* @param keepAliveTime when the number of threads is greater than

* the core, this is the maximum time that excess idle threads

* will wait for new tasks before terminating.

* @param unit the time unit for the keepAliveTime

* argument.

* @param workQueue the queue to use for holding tasks before they

* are executed. This queue will hold only the <tt> Runnable </tt>

* tasks submitted by the <tt> execute </tt> method.

* @param handler the handler to use when execution is blocked

* because the thread bounds and queue capacities are reached.

* @throws IllegalArgumentException if corePoolSize, or

* keepAliveTime less than zero, or if maximumPoolSize less than or

* equal to zero, or if corePoolSize greater than maximumPoolSize.

* @throws NullPointerException if <tt> workQueue </tt>

* or <tt> handler </tt> are null.

*/

public ThreadPoolExecutor( int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue<Runnable> workQueue,

RejectedExecutionHandler handler) {

this (corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,

Executors. defaultThreadFactory (), handler);

}

corePoolSize ： 线程池维护线程的最少数量，哪怕是空闲的。

maximumPoolSize ：线程池维护线程的最大数量。

keepAliveTime ： 线程池维护线程所允许的空闲时间。

unit ： 线程池维护线程所允许的空闲时间的单位。

workQueue ： 线程池所使用的缓冲队列，改缓冲队列的长度决定了能够缓冲的最大数量。

拒绝任务：拒绝任务是指当线程池里面的线程数量达到 maximumPoolSize 且 workQueue 队列已满的情况下被尝试添加进来的任务。

handler ： 线程池对拒绝任务的处理策略。在 ThreadPoolExecutor 里面定义了 4 种 handler 策略，分别是

1. CallerRunsPolicy ：这个策略重试添加当前的任务，他会自动重复调用 execute() 方法，直到成功。

2. AbortPolicy ：对拒绝任务抛弃处理，并且抛出异常。

3. DiscardPolicy ：对拒绝任务直接无声抛弃，没有异常信息。

4. DiscardOldestPolicy ：对拒绝任务不抛弃，而是抛弃队列里面等待最久的一个线程，然后把拒绝任务加到队列。

 

一个任务通过 execute(Runnable) 方法被添加到线程池，任务就是一个 Runnable 类型的对象，任务的执行方法就是 Runnable 类型对象的 run() 方法。

当一个任务通过 execute(Runnable) 方法欲添加到线程池时，线程池采用的策略如下：

1. 如果此时线程池中的数量小于 corePoolSize ，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

2. 如果此时线程池中的数量等于 corePoolSize ，但是缓冲队列 workQueue 未满，那么任务被放入缓冲队列。

3. 如果此时线程池中的数量大于 corePoolSize ，缓冲队列 workQueue 满，并且线程池中的数量小于 maximumPoolSize ，建新的线程来处理被添加的任务。

4. 如果此时线程池中的数量大于 corePoolSize ，缓冲队列 workQueue 满，并且线程池中的数量等于 maximumPoolSize ，那么通过 handler 所指定的策略来处理此任务。

处理任务的优先级为：

核心线程 corePoolSize 、任务队列 workQueue 、最大线程 maximumPoolSize ，如果三者都满了，使用 handler 处理被拒绝的任务。当线程池中的线程数量大于 corePoolSize 时，如果某线程空闲时间超过 keepAliveTime ，线程将被终止。这样，线程池可以动态的调整池中的线程数。

理解了上面关于 ThreadPoolExecutord 的介绍，应该就基本能了解它的一些使用，不过在 ThreadPoolExocutor 里面有个关键的 Worker 类，所有的线程都要经过 Worker 的包装。这样才能够做到线程可以复用而无需重新创建线程。

同时 Executors 类里面有 newFixedThreadPool(),newCachedThreadPool() 等几个方法，实际上也是间接调用了 ThreadPoolExocutor ，不过是传的不同的构造参数。

下面通过一个例子的执行结果来理解

 

代码：

 

上面代码定义了一个 corePoolSize 为 2 ， maximumPoolSize 为 3 ， workerQuene 容量为 3 的线程池，也就是说在饱和状态下，只能容纳 6 个线程， 3 个是运行状态， 3 个在队列里面。同时代码又往线程池里面添加了 9 个线程，每个线程会运行 2 秒，这样必然会到达饱和状态。而饱和状态就涉及到对拒绝任务的处理策略，本处采用了 ThreadPoolExecutor.DiscardOldestPolicy() 的 运行结果如下：

put task@ 1

start ..task@ 1

put task@ 2

start ..task@ 2

put task@ 3

put task@ 4

put task@ 5

start ..task@ 3

put task@ 6

put task@ 7

put task@ 8

put task@ 9

start ..task@ 8

start ..task@ 9

采用 ThreadPoolExecutor.DiscardOldestPolicy() 的 运行结果如下：

put task@ 1

start ..task@ 1

put task@ 2

start ..task@ 2

put task@ 3

put task@ 4

put task@ 5

start ..task@ 3

put task@ 6

start ..task@ 6

start ..task@ 4

start ..task@ 5

put task@ 7

start ..task@ 7

put task@ 8

put task@ 9

start ..task@ 8

start ..task@ 9

采用 ThreadPoolExecutor.AbortPolicy() 的 运行结果如下：

put task@ 1

start ..task@ 1

put task@ 2

start ..task@ 2

put task@ 3

put task@ 4

put task@ 5

start ..task@ 3

put task@ 6

java.util.concurrent.RejectedExecutionException

at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution( ThreadPoolExecutor.java:1477 )

at java.util.concurrent.ThreadPoolExecutor.reject( ThreadPoolExecutor.java:384 )

at java.util.concurrent.ThreadPoolExecutor.execute( ThreadPoolExecutor.java:867 )

at TestThreadPool.main( TestThreadPool.java:22 )

put task@ 7

java.util.concurrent.RejectedExecutionException

at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution( ThreadPoolExecutor.java:1477 )

at java.util.concurrent.ThreadPoolExecutor.reject( ThreadPoolExecutor.java:384 )

at java.util.concurrent.ThreadPoolExecutor.execute( ThreadPoolExecutor.java:867 )

at TestThreadPool.main( TestThreadPool.java:22 )

put task@ 8

java.util.concurrent.RejectedExecutionException

at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution( ThreadPoolExecutor.java:1477 )

at java.util.concurrent.ThreadPoolExecutor.reject( ThreadPoolExecutor.java:384 )

at java.util.concurrent.ThreadPoolExecutor.execute( ThreadPoolExecutor.java:867 )

at TestThreadPool.main( TestThreadPool.java:22 )

put task@ 9

java.util.concurrent.RejectedExecutionException

at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution( ThreadPoolExecutor.java:1477 )

at java.util.concurrent.ThreadPoolExecutor.reject( ThreadPoolExecutor.java:384 )

at java.util.concurrent.ThreadPoolExecutor.execute( ThreadPoolExecutor.java:867 )

at TestThreadPool.main( TestThreadPool.java:22 )

start ..task@ 4

start ..task@ 5

采用 ThreadPoolExecutor.DiscardPolicy() 的 运行结果如下：

put task@ 1

start ..task@ 1

put task@ 2

start ..task@ 2

put task@ 3

put task@ 4

put task@ 5

start ..task@ 3

put task@ 6

put task@ 7

put task@ 8

put task@ 9

start ..task@ 4

start ..task@ 5

从运行结果可以看出不同的 Handler 策略对拒绝任务的处理方式。

目前还只偏重在使用层面的理解，底层细节的原理还有待日后学习，欢迎交流。

 

 

本文部分内容和例子参考了： http://blog.youkuaiyun.com/imicro/archive/2007/08/29/1763955.aspx

 

 

Java线程池ThreadPoolExecutor背后的秘密与实践
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
05-12 170万+
本文深入分析了Java线程池ThreadPoolExecutor的工作原理、核心参数以及配置策略。通过详细讲解线程池的创建、任务调度和线程管理机制，帮助开发者理解如何高效使用线程池来处理并发任务。文章还探讨了常见的性能瓶颈和优化方法，如合理配置线程池参数、选择适当的拒绝策略等，旨在提升应用的并发处理能力和稳定性。最终，读者将能够根据不同场景灵活调整线程池配置，从而有效提升系统性能。
Java线程池 ThreadPoolExecutor 业务线程池
岸河世界
12-31 1957
1.什么是业务线程池？ 在业务开发中，用来处理业务的线程池。 2.为什么需要业务线程池？ 大多数同学都是做业务开发的，很多业务的操作并非要求一定是同步的。例如，对于一系列连续的业务逻辑处理，很多都是数据的组装，拼接，查询，或者将数据同步给各个下层业务（对事务性没有严格要求）；或者对数据的批量操作；这些都可以是异步的。通常业务项目使用的都是的servlet框架，都是使用一个线程进行业务逻辑处理，这种模型是通用的，但不一定是最佳的，不一定是最适合的。需要我们业务开发者根据实际的业务场景去灵活应用，达到最快的响.
java学习笔记_线程
今生今世的专栏
05-03 1159
一、Java线程：概念与原理 1、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多
Java线程详解
观千剑而后识器，操千曲而后晓声。
08-16 8915
Java线程：概念与原理 一、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。   线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线
ThreadPoolTaskExecutor原理解析与用法讲解
最新发布
技术人集结地
11-17 1156
ThreadPoolTaskExecutor是Spring对Java线程池的封装，简化了异步任务执行和管理。其核心原理包括任务提交规则（核心线程、队列、最大线程）、线程生命周期管理（复用与回收）以及与Spring生态的无缝集成。通过配置核心线程数、队列容量等参数，可优化异步处理性能。适用于@Async注解方法、批量任务并行化等场景。使用时需注意队列容量平衡、拒绝策略选择、线程上下文传递等问题，避免资源泄漏。合理配置可提升系统并发能力，确保稳定运行。
线程池7：线程池拒绝任务的两个时机；线程池拒绝任务的四种策略简介（AbortPolicy，DiscardPolicy，DiscardOldestPolicy，CallerRunsPolicy；）；
小枯林的博客
04-13 4527
说明： （1）本篇博客主要介绍线程池拒绝任务的两个时机；线程池拒绝任务的四种策略； 目录 一：拒绝任务的时机； （1）当线程池关闭后，新来的任务就会被拒绝； （2）当线程池的最大线程数、队列容量都有接线，并且都满了；继续添加任务时就会拒绝； 二：拒绝的策略； （1）AbortPolicy策略； （2）DiscardPolicy策略； （3）DiscardOldestPolicy策略； （4）CallerRunsPolicy策略； 一：拒绝任务的时机； （1）当线程池关闭后，.
当FutureTask遇上DiscardPolicy，有坑
i余数的博客
01-10 950
今天来了解下当 FutureTask 遇上 DiscardPolicy 或 DiscardOldestPolicy 时容易掉的坑，然后分析分析问题产生的原因以及如何规避这类问题。
【JAVA 多线程】线程池 ThreadPoolExecutor使用详解
vdssdf的博客
04-11 2340
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,时间单位，任务队列,创建线程工厂,任务的拒绝策略);线程池判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作 线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下个流程。线程池判断工作队列是否已经满。如果工作队列没有满，则将新提交的任务存储在这 个工作队列里。如果工作队列满了，则进入下个流程。
java threadpoolexecutor api_ThreadPoolExecutor.CallerRunsPolicy
weixin_36197669的博客
02-27 570
ThreadPoolExecutor.CallerRunsPolicy ClassDefinitionAssembly:Mono.Android.dllA handler for rejected tasks that runs the rejected taskdirectly in the calling thread of the execute method,unless the exec...
ThreadPoolExecutor里面4种拒绝策略--CallerRunsPolicy
chikoucha6215的博客
08-19 7734
首先介绍一下ThreadPoolExecutor构造方法： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, ...
Java线程池ThreadPoolExecutor原理及使用实例
08-19
Java线程池ThreadPoolExecutor原理及使用实例 Java线程池ThreadPoolExecutor是Java并发编程中的一种基本机制，主要用于管理和执行任务的线程池。下面对其原理和使用实例进行详细介绍。 线程池概述 线程池是一个...
java线程池ThreadPoolExecutor类使用详解.docx
06-21
在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了...
Java线程池ThreadPoolExecutor极简教程
Trouvailless的博客
05-27 483
ThreadPoolExecutor 简介 ThreadPoolExecutor 是 java.util.concurrent 包下的一个类，在jdk1.5版本引入，帮助开发人员管理线程并方便地执行并行任务。 通俗来说，ThreadPoolExecutor 的作用是生产和管理线程池的，可以通过调用其 execute 方法和 submit 方法执行多线程任务。 ThreadPoolExecutor 使用 创建执行器 ExecutorService 对象和 ThreadPoolExecutor 的关系
线程池——ThreadPoolExecutor
qq_18684463的博客
04-17 3678
线程池（Thread Pool）：把一个或多个线程通过统一的方式进行调度和重复使用的技术，避免了因为线程过多而带来使用上的开销。为什么要使用线程池？可重复使用已有线程，避免对象创建、消亡和过度切换的性能开销。避免创建大量同类线程所导致的资源过度竞争和内存溢出的问题。支持更多功能，比如延迟任务线程池（newScheduledThreadPool）和缓存线程池（newCachedThreadPool）等。
说说ThreadPoolExecutor饱和策略CallerRunsPolicy
热门推荐
懂幸福，爱生活
06-21 1万+
之前在文章深入线程池ThreadPoolExecutor中聊到了线程池
线程池之ThreadPoolExecutor
Itmylove8的博客
08-22 364
线程池的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，那么超出数量的线程排队等候，等其他线程执行完毕再从队列中取出任务来执行。 在开发过程中，合理地使用线程池能够带来3个好处： 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗； 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行； 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，
ThreadPoolExecutor.CallerRunsPolicy 可伸缩队列
weixin_35757531的博客
02-14 1770
ThreadPoolExecutor.CallerRunsPolicy 是一种可伸缩队列策略。这种策略是当线程池中的线程数达到最大值，并且已提交的任务数大于线程池中的线程数时，任务将在调用者线程中执行，而不是在线程池中的线程中执行。这个策略可以控制任务的执行速度，防止线程池中的任务过多导致的资源耗尽。 ...
一种关于ThreadPoolExecutor拒绝策略之CallerRunsPolicy（调用者运行策略）的实验研究
m0_58639137的博客
11-09 2341
线程池 CallerRunsPolicy 拒绝策略
使用有界队列的线程池使用DiscardOldestPolicy拒绝策略
千淘万漉
12-02 7365
如果使用无界队列很简单，开启核心线程数，多余的全部阻塞直到内存耗尽。 如果使用有界队列，要清楚工作流程： * 若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程， * 若大于corePoolSize，则会将任务加入队列， * 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程， * 若线程数大于maximumPoolSize，则执行拒绝策略
java 线程池 ThreadPoolExecutor
09-29
<think>我们刚刚讨论过Java线程池ExecutorService的全面内容，现在用户明确要求了解ThreadPoolExecutor的具体信息。从用户的问题和引用来看，需要聚焦ThreadPoolExecutor的使用方法、工作原理和应用场景。 用户提供的引用材料强调ThreadPoolExecutor是Java线程池的核心实现，这点非常重要。引用[1]提到它管理预先创建的线程提高性能，引用[2]强调其配置选项和设计思想，引用[3]说明线程复用机制，引用[4]则指出其类继承关系。这些都需要整合到回答中。 考虑到用户可能是开发人员，我将从三个维度构建回答：使用方式会重点演示创建参数和任务提交，原理部分解析任务调度和线程复用机制，应用场景则结合不同业务需求。特别要注意引用[3]提到的任务队列选择和线程复用特性，这关系到实际性能表现。 在回答结构上，准备用三大部分展开：使用指南包含创建线程池的代码示例和工作流程说明；核心原理部分会解释状态管理和任务调度流程；应用场景则对比不同线程池类型。每个关键点都会自然标注引用来源，比如线程复用机制说明后添加[^3]。 最后会生成三个相关问题：钩子方法的使用、拒绝策略的深度解析、以及生产环境监控方案。这些问题既延续当前主题，又能帮助用户进阶学习。 </think>以下是关于 Java 线程池 `ThreadPoolExecutor` 的核心解析，涵盖使用、原理及应用场景： --- ### 一、使用指南 #### 1. 创建线程池（推荐手动配置） ```java ThreadPoolExecutor executor = new ThreadPoolExecutor( 4, // 核心线程数（常驻） 10, // 最大线程数 60, TimeUnit.SECONDS, // 非核心线程空闲存活时间 new ArrayBlockingQueue<>(100), // 有界任务队列 Executors.defaultThreadFactory(), // 线程工厂 new ThreadPoolExecutor.AbortPolicy() // 拒绝策略 ); ``` - **关键参数**： - **核心线程**：默认常驻，即使空闲也不回收 - **任务队列**：推荐有界队列（如 `ArrayBlockingQueue`）防 OOM - **拒绝策略**：默认 `AbortPolicy`（队列满时抛异常） #### 2. 提交任务 ```java // 无返回值任务 executor.execute(() -> System.out.println("Task running")); // 有返回值任务 Future<String> future = executor.submit(() -> { Thread.sleep(1000); return "Result"; }); String result = future.get(); // 阻塞获取结果 ``` #### 3. 关闭线程池 ```java executor.shutdown(); // 优雅关闭：停止接收新任务，处理完队列任务 if (!executor.awaitTermination(60, TimeUnit.SECONDS)) { executor.shutdownNow(); // 强制终止剩余任务 } ``` > **最佳实践**：`shutdown()` + `awaitTermination()` 组合确保安全关闭[^3] --- ### 二、核心原理 #### 1. 任务调度流程 1. 提交任务 → 优先使用核心线程执行 2. 核心线程满载 → 任务进入阻塞队列 3. 队列满载 → 创建非核心线程（不超过 `maxPoolSize`） 4. 线程和队列均满 → 触发拒绝策略[^1] #### 2. 线程复用机制 - **Worker 工作线程**： - 封装 `Thread` 和初始任务 `firstTask` - 循环执行 `getTask()` 从队列获取新任务 - **线程回收**： - 非核心线程空闲超过 `keepAliveTime` 后自动销毁 - 核心线程默认常驻（可通过 `allowCoreThreadTimeOut(true)` 配置回收） #### 3. 状态管理（原子变量 `ctl`） $$ \begin{array}{c|c} \text{高 3 位} & \text{低 29 位} \\ \hline \text{RUNNING} & \text{线程数} \\ \text{SHUTDOWN} & \\ \text{STOP} & \\ \text{TIDYING} & \\ \text{TERMINATED} & \\ \end{array} $$ > 状态转换：RUNNING → SHUTDOWN → TIDYING → TERMINATED[^4] --- ### 三、应用场景 | **场景类型** | **推荐配置** | **案例** | |---------------------|---------------------------------------|------------------------------| | **CPU 密集型** | 线程数 ≈ CPU 核数 | 数据加密、图像处理 | | **I/O 密集型** | 线程数 = CPU 核数 × (1 + 等待时间/计算时间) | 网络请求、文件读写[^2] | | **定时任务** | 使用 `ScheduledThreadPoolExecutor` | 定时报表、心跳检测 | | **高吞吐异步处理** | `CachedThreadPool` + 限流 | 消息队列消费（需防 OOM）[^3] | --- ### 四、调优与问题解决 1. **线程数公式**： $$ N_{\text{threads}} = N_{\text{CPU}} \times U_{\text{CPU}} \times (1 + \frac{W}{C}) $$ - $N_{\text{CPU}}$：CPU 核数（`Runtime.getRuntime().availableProcessors()`） - $U_{\text{CPU}}$：目标 CPU 利用率（建议 0.8） - $W/C$：等待时间与计算时间的比值 2. **常见问题**： - **任务堆积** → 使用有界队列 + `CallerRunsPolicy` 策略 - **线程泄露** → 通过 `ThreadFactory` 添加 `UncaughtExceptionHandler` - **CPU 过高** → 降低线程数或优化任务逻辑[^1] > **监控指标**： > ```java > executor.getActiveCount(); // 活动线程数 > executor.getQueue().size(); // 队列积压量 > executor.getCompletedTaskCount(); // 已完成任务 > ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值