JAVA线程池

本文详细介绍了Java线程池的基本用法及四种常见线程池的特性与应用场景,包括fixed、cached、scheduled和single thread executor,并提供了配置线程池大小的一般原则。

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

JAVA线程池

基本用法

先来看个基本用法

ExecutorServiceexecutor=Executors.newFixedThreadPool(3);
executor.execute(newRunnable() {
   
@Override
   
public void run() {
       
//do something
   
}
})
;

 

上边代码创建了一个线程池,里面是有固定3个线程的线程池,然后使用execute执行一个任务,把这个runnable丢到线程池里执行。

概述

ExecutorService是线程池的管理类

Executor是线程池创建的工厂类

创建线程池一般会调用Executor的newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,newSingleThreadExecutor的这四个方法之一,来创建需要的线程池。

线程池,一般有几个基本参数

corePoolSize 核心线程数

maximumPoolSize 最大线程数

keepAliveTime超时时间

 

线程池的类是ThreadPoolExecutor,corePoolSize的作用主要是控制线程的停止。

只要线程数大于corePoolSize,就会触发以下逻辑。如果某个线程执行完他的任务了,会尝试去任务队列中取,如果在keepAliveTime内没取到任务(可能任务队列为空),那就会停止此线程,并且提醒其他idle的线程也停止,这样总线程数就降下来了。

而线程数降到corePoolSize之后就不会去停止线程了。这样线程池中一直会有corePoolSize个线程,所以有人称为核心线程,当然要记住核心线程不是一种特殊的线程,说不定这个时候线程池里的核心线程是这些,过一会线程池里的核心线程是另一些了,核心线程只是线程池的一种概念,并不是指某个线程的属性。

还有一种特殊情况,如果把allowCoreThreadTimeOut设置为true,那corePoolSize就无法控制线程的停止了,任何线程只要空闲时间超过keepAliveTime就会停止

 

线程池执行任务规则如下:

1、        初始状态线程池内没有线程,来了任务,就会立刻创建线程。

2、        当前线程数小于corePoolSize,那就来一个任务,创建一个线程。

3、        当前线程数达到corePoolSize,来了个任务,那就丢到任务队列里面去排队,等待某个线程执行完他当前的任务再来任务队列中取

4、        如果任务队列也满了,但是当前总线程数不超过maximumPoolSize,那就启动一个额外线程来处理。此时的线程数大于corePoolSize,小于maximumPoolSize,此时会触发线程闲置久了就停止的逻辑。

5、        如果任务队列也满了,但是当前总线程数到达maximumPoolSize,那就拒绝执行任务,调用一个RejectedExecutionHandler的rejectedExecution来通知调用者。


相关代码可以查看java.util.concurrent.ThreadPoolExecutor#execute



我们再来看看刚才四种方法产生的不同的线程池。

newFixedThreadPool

newFixedThreadPool得到的是ThreadPoolExecutor,里面只有核心线程,没有非核心线程,所有线程都处于活动状态,核心线程的数量固定,任务队列大小没有限制。所以,只用考虑上边的规则1和规则2。来了任务之后,核心线程有空就交给核心线程处理,核心线程没空就在任务队列里等待。所有线程一直开启,可以很快的响应任务,但是闲置状态比较浪费资源。适合处理少量耗时大的任务。

代码如下

return new ThreadPoolExecutor(nThreads, nThreads,
                              0L, TimeUnit.MILLISECONDS,
                              new LinkedBlockingQueue<Runnable>());

 newCachedThreadPool

newCachedThreadPool得到的也是ThreadPoolExecutor,与newFixedThreadPool对比很明显,newCachedThreadPool得到的线程池,没有核心线程,只有非核心线程,线程的最大数量是Integer.MAX_VALUE,所有线程的闲置时间不能超过60s,否则会被回收。这里的任务队列是SynchronousQueue,可以看做空,无法存储任务,那么一个任务到来之后,就检查是否有闲置的线程,有就交给闲置的线程去处理,如果没有就新开启一个线程去处理。闲置状态所有线程都会因为超时被停止,占资源少。有了任务得去开启线程,响应没有FixedThreadPool来的快,适合频繁的低耗时任务。

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

 

 newScheduledThreadPool

newScheduledThreadPool得到的是ScheduledThreadPoolExecutor,他是ThreadPoolExecutor的子类。这个线程池里有一定数量的核心线程,也有非核心线程,线程总数量为Integer.MAX_VALUE。非核心线程的保活时间为10ms,一般用完就很快被回收。

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}

 

这个线程池的主要用法如下,主要是用于带控制的任务,比如多久时间以后执行某个任务,按什么样的周期执行任务,主要用于定时执行任务。

public ScheduledFuture<?> schedule(Runnable command,
                                   long delay,
                                   TimeUnit unit)

 

典型用法:

//在2000ms之后执行某个任务

pool.schedule(runnable,2000,TimeUnit.MILLISECONDS)


//10ms之后执行,2000ms执行依次

pool.scheduleAtFixedRate(runnable,10,2000,TimeUnit.MILLISECONDS)

周期性的执行任务的时候,如果其中某次出了异常,那就会中断,不在继续执行任务。所有最好把任务加上异常捕获。

比如

  private static class BusinessTask implements Runnable{
       @Override
       public void run() {
           //捕获所有的异常,保证定时任务能够继续执行
           try{
                System.out.println("任务开始...");
                //doBusiness();
                System.out.println("任务结束...");
           }catch (Throwable e) {
                // donothing
           }
       }
    }


 newSingleThreadExecutor

再来看newSingleThreadExecutor,这个得到的线程池和前面几个都不同,得到FinalizableDelegatedExecutorService,其他几个都是ThreadPoolExecutor或者他的子类。这个类顾名思义就是,本质上只有一个线程。所有任务都会依次在这个任务中执行,可以有效保证顺序。比如打日志到sd卡时,就必须保证有序。

 

如何配置线程池大小:

  一般需要根据任务的类型来配置线程池大小:

  如果是CPU密集型任务,就需要尽量压榨CPU,参考值可以设为 NCPU+1

  如果是IO密集型任务,参考值可以设置为2*NCPU


  当然,这只是一个参考值,具体的设置还需要根据实际情况进行调整,比如可以先将线程池大小设置为参考值,再观察任务运行情况和系统负载、资源利用率来进行适当调整。

 参考文献

android开发艺术探索

https://segmentfault.com/a/1190000000371905

http://blog.youkuaiyun.com/nei504293736/article/details/7534084

http://www.cnblogs.com/dolphin0520/p/3932921.html


 

<think>我们正在讨论Java线程池的使用和原理。根据引用内容,线程池Java中主要通过ThreadPoolExecutor类实现,从JDK5开始内置支持。线程池的好处包括重用线程、控制并发数量、管理线程生命周期等。常见的线程池类型有:FixedThreadPool(固定容量)、CachedThreadPool(缓存)、SingleThreadExecutor(单线程)、ScheduledThreadPool(定时任务)以及通过ThreadPoolExecutor自定义创建。我们将分步骤讲解:1.线程池的核心原理2.创建线程池的五种方式(包括不推荐的原因)3.重点讲解ThreadPoolExecutor及其参数4.线程池的工作机制(任务提交、执行、拒绝策略等)5.使用示例注意:根据引用[3]和[4],ThreadPoolExecutor是构建线程池的核心类,因此我们将重点分析。步骤1:线程池的核心原理线程池通过预先创建一定数量的线程并维护它们,避免频繁创建和销毁线程的开销。当有任务提交时,线程池分配空闲线程执行任务;若没有空闲线程,任务将被放入队列等待;当队列满时,根据设定的拒绝策略处理。步骤2:创建线程池的五种方式(引用[3]和[5])1.newCachedThreadPool:创建一个可缓存的线程池,线程数可无限增加(最大为Integer.MAX_VALUE),空闲线程默认60秒回收。不推荐原因:可能创建过多线程导致OOM。2.newFixedThreadPool:固定大小的线程池,使用无界队列(LinkedBlockingQueue)。不推荐原因:无界队列可能堆积大量任务导致OOM。3.newSingleThreadExecutor:只有一个线程的线程池,同样使用无界队列。不推荐原因同上。4.newScheduledThreadPool:用于定时或周期性任务的线程池。不推荐直接使用的原因是其最大线程数为Integer.MAX_VALUE,可能创建过多线程。5.推荐方式:直接使用ThreadPoolExecutor构造函数创建,可明确指定参数,避免资源耗尽。步骤3:ThreadPoolExecutor的七个参数(引用[3]和[4])构造方法如下:```javapublicThreadPoolExecutor(intcorePoolSize,intmaximumPoolSize,longkeepAliveTime,TimeUnitunit,BlockingQueue<Runnable>workQueue,ThreadFactorythreadFactory,RejectedExecutionHandlerhandler)```1.corePoolSize:核心线程数,即使空闲也不会被回收(除非设置allowCoreThreadTimeOut)2.maximumPoolSize:最大线程数3.keepAliveTime:非核心线程的空闲存活时间4.unit:存活时间单位5.workQueue:任务队列(常用有ArrayBlockingQueue有界队列,LinkedBlockingQueue无界队列,SynchronousQueue同步移交队列)6.threadFactory:线程工厂,用于创建线程7.handler:拒绝策略(当线程池和队列都满时触发)步骤4:线程池的工作机制(任务提交执行流程)1.提交任务后,如果当前线程数小于corePoolSize,则创建新线程执行(即使有空闲线程)。2.如果当前线程数>=corePoolSize,则将任务放入workQueue。3.如果队列已满,且线程数小于maximumPoolSize,则创建新的非核心线程执行。4.如果队列已满且线程数达到maximumPoolSize,则触发拒绝策略。拒绝策略(handler)有四种:-AbortPolicy(默认):抛出RejectedExecutionException-CallerRunsPolicy:由调用线程执行该任务-DiscardPolicy:丢弃任务,不抛异常-DiscardOldestPolicy:丢弃队列最前面的任务,然后重试步骤5:使用示例(以ThreadPoolExecutor为例)下面是一个自定义线程池的示例:```javaimportjava.util.concurrent.*;publicclassThreadPoolExample{publicstaticvoidmain(String[]args){//创建线程池ThreadPoolExecutorexecutor=newThreadPoolExecutor(2,//核心线程数5,//最大线程数60,//空闲线程存活时间TimeUnit.SECONDS,newArrayBlockingQueue<>(10),//有界队列,容量10Executors.defaultThreadFactory(),newThreadPoolExecutor.AbortPolicy());//拒绝策略:直接抛出异常//提交任务for(inti=0;i<15;i++){finalinttaskId=i;executor.execute(()->{System.out.println("Task"+taskId+"isrunningonthread"+Thread.currentThread().getName());try{Thread.sleep(1000);//模拟任务执行}catch(InterruptedExceptione){e.printStackTrace();}});}//关闭线程池executor.shutdown();}}```注意:实际任务数15个,核心线程2个,最大线程5个,队列容量10个。因此前2个任务会创建核心线程执行,接下来的10个任务放入队列,然后第13、14、15个任务会创建非核心线程(共3个非核心线程,总线程数5个)。如果超过15个任务(比如16个),则会触发拒绝策略。最后,关于线程池的关闭,可以使用shutdown()(等待已提交任务完成)或shutdownNow()(尝试中断所有线程,停止任务)。总结:使用线程池时,推荐直接使用ThreadPoolExecutor构造函数,根据实际需求设置参数,避免使用Executors工厂方法可能导致的资源耗尽问题。相关问题:1.线程池中任务队列有哪些类型?各自特点是什么?2.如何合理设置线程池的核心线程数和最大线程数?3.线程池的拒绝策略有哪些?如何自定义拒绝策略?4.如何监控线程池的运行状态?5.线程池中线程是如何创建的?如何自定义线程工厂?</think>### Java线程池使用指南与原理分析 Java线程池通过`java.util.concurrent`包实现,核心类是`ThreadPoolExecutor`。线程池的核心思想是**复用线程**,避免频繁创建销毁线程的开销。线程池中的线程执行完任务后不会销毁,而是回到池中等待新任务[^2]。 --- #### **一、线程池的创建方式** Java提供5种创建线程池的方法(实际都是`ThreadPoolExecutor`的包装): 1. **固定大小线程池**(推荐) ```java ExecutorService fixedPool = Executors.newFixedThreadPool(5); // 固定5个线程 ``` - 特点:核心线程数=最大线程数,使用无界队列`LinkedBlockingQueue` - 风险:任务过多时可能导致OOM(队列无限增长)[^5] 2. **缓存线程池**(不推荐) ```java ExecutorService cachedPool = Executors.newCachedThreadPool(); ``` - 特点:线程数无上限(`Integer.MAX_VALUE`),空闲线程60秒回收 - 风险:高并发时可能创建大量线程导致OOM[^3] 3. **单线程池** ```java ExecutorService singlePool = Executors.newSingleThreadExecutor(); ``` - 特点:仅1个线程,保证任务顺序执行 - 风险:同固定线程池(无界队列问题) 4. **定时任务线程池** ```java ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3); ``` 5. **推荐做法:手动创建`ThreadPoolExecutor`** ```java ThreadPoolExecutor customPool = new ThreadPoolExecutor( 4, // 核心线程数 10, // 最大线程数 60, // 空闲线程存活时间(秒) TimeUnit.SECONDS, new ArrayBlockingQueue<>(100), // 有界队列(容量100) new ThreadPoolExecutor.AbortPolicy() // 拒绝策略 ); ``` --- #### **二、核心参数详解(7个关键参数)** ```java public ThreadPoolExecutor( int corePoolSize, // 核心线程数(常驻线程) int maximumPoolSize, // 最大线程数 long keepAliveTime, // 非核心线程空闲存活时间 TimeUnit unit, // 时间单位 BlockingQueue<Runnable> workQueue, // 任务队列 ThreadFactory threadFactory, // 线程工厂 RejectedExecutionHandler handler // 拒绝策略 ) ``` 1. **任务队列类型** - `ArrayBlockingQueue`:**有界队列**(推荐),避免OOM - `LinkedBlockingQueue`:**无界队列**(默认) - `SynchronousQueue`:不存储任务,直接移交线程 2. **拒绝策略**(当队列和线程池全满时触发) - `AbortPolicy`(默认):抛出`RejectedExecutionException` - `CallerRunsPolicy`:由调用者线程直接执行任务 - `DiscardPolicy`:静默丢弃任务 - `DiscardOldestPolicy`:丢弃队列最旧的任务 --- #### **三、线程池工作原理** 1. **任务提交流程**: - 当线程数 < `corePoolSize`,**创建新线程**执行任务 - 当线程数 >= `corePoolSize`,任务进入**工作队列** - 当队列已满且线程数 < `maximumPoolSize`,**创建临时线程**执行 - 当队列满且线程数达到`maximumPoolSize`,触发**拒绝策略**[^4] 2. **线程回收机制**: - 核心线程默认不回收(除非设置`allowCoreThreadTimeOut(true)`) - 非核心线程空闲超过`keepAliveTime`后自动销毁 --- #### **四、最佳实践** 1. **参数设置建议**: - CPU密集型任务:核心线程数 = CPU核数 + 1 - IO密集型任务:核心线程数 = 2 * CPU核数 - 使用**有界队列**防止资源耗尽 - 拒绝策略选择`CallerRunsPolicy`保证任务不丢失 2. **代码示例**: ```java ThreadPoolExecutor executor = new ThreadPoolExecutor( Runtime.getRuntime().availableProcessors(), // 核心线程数=CPU核数 Runtime.getRuntime().availableProcessors() * 2, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(500), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy() ); // 提交任务 executor.execute(() -> System.out.println("Task running")); // 优雅关闭 executor.shutdown(); executor.awaitTermination(1, TimeUnit.MINUTES); ``` 3. **注意事项**: - 避免使用`Executors`快捷方法(有OOM风险) - 监控线程池状态(通过`getActiveCount()`等方法) - 务必调用`shutdown()`释放资源 --- #### **五、原理解析** - **线程复用**:通过`Worker`类封装线程,循环从队列获取任务执行[^3] - **任务调度**:核心逻辑在`ThreadPoolExecutor.execute()`方法中 - **资源控制**:通过`BlockingQueue`实现生产者-消费者模型 > 线程池的本质是**资源池化技术**(Pooling),通过复用线程降低系统开销,同时提供流量缓冲和容错能力[^4]。 --- ### 相关问题 1. **为什么`FixedThreadPool`使用无界队列会导致OOM?如何避免?** 2. **线程池中`corePoolSize`和`maximumPoolSize`设置不当会产生什么后果?** 3. **如何实现一个自定义拒绝策略(如记录日志或降级处理)?** 4. **线程池的`shutdown()`和`shutdownNow()`有什么区别?** 5. **如何监控线程池的运行状态(如队列积压、活跃线程数)?** [^1]: ThreadPoolExecutor是Java线程池的核心实现类。 [^2]: JDK5开始内置线程池,线程执行后返回池中复用。 [^3]: 手动创建ThreadPoolExecutor可避免资源耗尽风险。 [^4]: 线程池通过队列缓冲和动态扩缩容管理任务。 [^5]: FixedThreadPool的无界队列可能导致OOM。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值