Java线程池ExecutorService

本文详细介绍了ExecutorService的生命周期管理方法,包括运行、关闭和终止状态,并展示了如何使用newSingleThreadExecutor、newFixedThreadPool和newCachedThreadPool创建不同类型的线程池。同时,通过execute和submit方法执行线程,并在结束时正确地调用shutdown方法来控制线程池的生命周期。

ExecutorService扩展了Executor并添加了一些生命周期管理的方法。一个Executor的生命周期有三种状态运行、关闭和终止。
Executor创建时处于运行状态。当调用ExecutorService.shutdown()后,处于关闭状态,isShutdown()方法返回true。这时,不应该再向Executor中添加任务,所有已添加的任务执行完毕后,Executor处于终止状态,isTerminated()返回true。如果Executor处于关闭状态,往Executor提交任务会抛出unchecked exception RejectedExecutionException。

//返回的线程池中有以一个线程
    ExecutorService  executorService1 = Executors.newSingleThreadExecutor();
//线程池中的线程数量可以自己手动指定
    ExecutorService  executorService2 = Executors.newFixedThreadPool(10);
//创建一个动态扩展的线程池
    ExecutorService  executorService3 = Executors.newCachedThreadPool();
//execute(Runable())方法执行线程
ExecutorService  executorService = Executors.newFixedThreadPool(4);

        List<Runnable>  runnableList = new ArrayList<>();
        for(int i = 0;i<6;i++){
            final int  m = i;
            runnableList.add(new Runnable() {

                @Override
                public void run() {

                    for(int n = 0;n<10;n++){
                        System.out.println(Thread.currentThread().getName()+"      i="+ m +" n="+n);
                    }

                }
            });
        }

        for (Runnable runnable : runnableList) {
            executorService.execute(runnable);
        }


        executorService.shutdown();
//  submit(Callable())执行线程
//Future用来接收线程返回的执行结果
ExecutorService  executorService = Executors.newFixedThreadPool(4);
        int sumAll = 0;
        for(int i = 1;i<=6;i++){
          Future<Integer>   future =    executorService.submit(new Callable<Integer>() {

                @Override
                public Integer call() throws Exception {
                    int sum = 0;
                    for(int n = 1;n <=10;n++){
                        sum +=n;
                    }

                    return sum;
                }
            });
          sumAll = sumAll+ future.get();
        }


        System.out.println(sumAll);

        executorService.shutdown();

在使用时,可以创建一个单例模式的工具类来使用。

public class ThreadPoolUtil {
    private static final ExecutorService executorService =  Executors.newCachedThreadPool();
    public static ExecutorService getExecutorService(){
        return  executorService;
    }
}
<think>我们正在讨论Java线程池ExecutorService,用户希望了解其使用、原理及最佳实践。根据之前的对话历史和提供的参考资料,我们可以系统地组织回答。 参考资料摘要: [^1]:ThreadPoolExecutor是线程池的核心实现类,Executors工厂类提供便捷创建方法。 [^2]:ThreadPoolExecutor和ScheduledThreadPoolExecutor都实现了Executor和ExecutorService接口。 [^3]:线程池中的线程用Worker对象封装,Worker是ThreadPoolExecutor的内部类,持有线程池引用。 [^4]:介绍了不同类型的线程池(Fixed, Cached, SingleThread, Scheduled, WorkStealing)及其使用场景。 回答结构: 1. ExecutorService概述:介绍其在Java并发包中的地位和作用。 2. 使用指南:如何创建(通过Executors工厂或直接构造ThreadPoolExecutor)、提交任务、关闭线程池。 3. 核心原理:重点解释ThreadPoolExecutor的工作原理(任务调度、线程复用、队列管理、拒绝策略等)。 4. 最佳实践:参数配置、线程池选择、异常处理、监控等。 5. 常见问题与解决方案:如任务堆积、死锁、资源泄露等。 注意引用标注:在关键结论或数据后添加引用标识。 数学表达式:如线程池性能模型中的公式需要用$...$或$$...$$表示。 最后生成相关问题。 </think>### Java线程池`ExecutorService`的使用、原理及最佳实践 `ExecutorService`是Java并发包(`java.util.concurrent`)的核心接口,用于管理线程池的生命周期和任务执行。以下从使用、原理和实践三个维度展开: --- #### 一、使用指南 1. **创建线程池** 通过`Executors`工厂类或直接构造`ThreadPoolExecutor`实现: ```java // 工厂方法(推荐简单场景) ExecutorService fixedPool = Executors.newFixedThreadPool(10); // 固定大小线程池 [^4] ExecutorService cachedPool = Executors.newCachedThreadPool(); // 弹性线程池(需防OOM)[^4] ExecutorService singlePool = Executors.newSingleThreadExecutor(); // 单线程顺序执行 [^4] // 手动配置(推荐生产环境) ExecutorService customPool = new ThreadPoolExecutor( corePoolSize, // 核心线程数(常驻) maxPoolSize, // 最大线程数(队列满时扩容) keepAliveTime, // 非核心线程空闲存活时间 TimeUnit.SECONDS, new LinkedBlockingQueue<>(100), // 任务队列 new CustomRejectedPolicy() // 自定义拒绝策略 ); ``` 2. **提交任务** - `execute(Runnable task)`: 提交无返回值的任务 - `submit(Callable<T> task)`: 提交有返回值的任务,返回`Future<T>`对象 ```java Future<Integer> future = customPool.submit(() -> { // 计算逻辑 return 42; }); Integer result = future.get(); // 阻塞获取结果 ``` 3. **关闭线程池** ```java customPool.shutdown(); // 优雅关闭:停止接收新任务,处理完队列任务 customPool.shutdownNow(); // 强制关闭:中断所有线程(返回未处理任务列表) ``` --- #### 二、核心原理 1. **任务调度流程** - 提交任务时,优先创建核心线程执行(若核心线程数未满) - 核心线程满载后,任务进入阻塞队列 - 队列满载后,创建非核心线程(不超过`maxPoolSize`) - 线程和队列均满载时,触发拒绝策略 [^1][^2] 2. **线程复用机制** 线程池通过`Worker`内部类封装线程(继承`AQS`锁)[^3]: ```java private final class Worker extends AbstractQueuedSynchronizer implements Runnable { final Thread thread; // 实际工作线程 Runnable firstTask; // 初始任务 // 线程执行循环:从队列获取任务并执行 } ``` - 线程启动后循环执行`getTask()`从队列获取任务 - 空闲线程超时(`keepAliveTime`)后被回收 3. **生命周期状态** 通过原子变量`ctl`(32位)维护两种状态: - **高3位**:线程池状态(`RUNNING`, `SHUTDOWN`, `STOP`, `TIDYING`, `TERMINATED`) - **低29位**:有效线程数 状态转换关系: $$ \text{RUNNING} \xrightarrow{\text{shutdown()}} \text{SHUTDOWN} \xrightarrow{\text{队列空}} \text{TIDYING} \xrightarrow{\text{terminated()}} \text{TERMINATED} $$ [^2][^4] --- #### 三、最佳实践 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$:等待时间与计算时间的比值 - **队列容量**:根据业务峰谷值设置,避免`OOM`(如`ArrayBlockingQueue`有界队列)[^1] 2. **拒绝策略选择** | 策略 | 行为 | 适用场景 | |------|------|----------| | `AbortPolicy`(默认) | 抛出`RejectedExecutionException` | 需快速失败场景 | | `CallerRunsPolicy` | 由提交任务的线程执行 | 保证任务不丢失 | | `DiscardPolicy` | 静默丢弃任务 | 容忍数据丢失 | | `DiscardOldestPolicy` | 丢弃队列最旧任务并重试 | 时效性优先 | 3. **监控与调优** - 通过`ThreadPoolExecutor`方法监控: ```java pool.getActiveCount(); // 活动线程数 pool.getQueue().size(); // 队列积压量 ``` - **问题诊断**: - 线程饥饿:增大核心线程数或改用`SynchronousQueue` - CPU过高:降低线程数或优化任务逻辑 - OOM风险:使用有界队列并设置合理拒绝策略 [^4] 4. **场景化选型** | 线程池类型 | 特点 | 适用场景 | |------------|------|----------| | `FixedThreadPool` | 固定线程数 | 负载稳定的服务(如Web后端) | | `CachedThreadPool` | 线程自动回收 | 短时异步任务(需防OOM) | | `ScheduledThreadPool` | 支持定时任务 | 心跳检测、定时报表 [^4] | | `WorkStealingPool` | 工作窃取负载均衡 | CPU密集型并行计算 [^4] | --- #### 四、常见问题解决方案 1. **任务堆积导致OOM** **方案**:使用有界队列 + `CallerRunsPolicy`拒绝策略,限制提交速率。 2. **线程泄漏** **方案**:确保任务正确处理异常(避免线程因异常终止),或使用`ThreadFactory`定制线程的`UncaughtExceptionHandler`。 3. **死锁** **方案**:避免任务间循环依赖;使用`newWorkStealingPool()`利用工作窃取算法打破僵局 [^4]。 4. **资源竞争** **方案**:对共享资源使用`ConcurrentHashMap`等并发容器;控制线程数不超过$2 \times N_{\text{CPU}}$。 > **关键原则**:根据业务场景(I/O密集型或CPU密集型)动态调整参数,并通过压测验证[^1][^3]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值