探秘SpringBoot默认线程池：了解其运行原理与工作方式（@Async和ThreadPoolTaskExecutor）

文章目录

  • 文章导图
  • Spring封装的几种线程池
  • SpringBoot默认线程池
    • TaskExecutionAutoConfiguration（SpringBoot 2.1后）
      • 主要作用
      • 优势
      • 使用场景
      • 如果没有它
    • 2.1版本以后
      • 如何查看参数
      • 方式一：通过@Async注解--采用ThreadPoolTaskExecutor
        • determineAsyncExecutor-查找决定使用哪个线程池
        • 实操
        • @Async注意点
      • 方式二：直接注入 ThreadPoolTaskExecutor
    • 2.1版本以前
      • 方式一：通过@Async注解--采用SimpleAsyncTaskExecutor
      • 方式二：直接注入 ThreadPoolTaskExecutor
        • 直接注入报错
        • 解决：自定义一个线程池
    • 默认的线程池好用吗？
      • TaskExecutionAutoConfiguration？
      • SimpleAsyncTaskExecutor
      • 线程池核心线程数和最大线程数设置指南
        • 线程池参数介绍
        • 线程数设置考虑因素
        • CPU密集型任务的线程数设置
        • IO密集型任务的线程数设置
        • 实际应用中的线程数计算
        • 生产环境中的线程数设置
        • 线程池参数设置建议
        • 注意事项

线程池系列文章可参考下表，目前已更新3篇，还剩1篇TODO…

线程池系列：文章
Java基础线程池TODO…
CompletableFuture线程池从用法到源码再到应用场景：全方位了解CompletableFuture及其线程池
SpringBoot默认线程池（@Async和ThreadPoolTaskExecutor）探秘SpringBoot默认线程池：了解其运行原理与工作方式（@Async和ThreadPoolTaskExecutor）
SpringBoot默认线程池和内置Tomcat线程池你是否傻傻分不清SpringBoot默认线程池和内置Tomcat线程池？

文章导图

image-20240522213822974

Spring封装的几种线程池

Spring框架为了简化并发任务的处理，提供了几种线程池的封装实现，这些线程池可以直接在Spring应用程序中使用。以下是Spring中常见的几种线程池：

线程池类型描述特点
SimpleAsyncTaskExecutor非阻塞的线程池，为每个任务创建新线程，不限制线程数量。不重用线程，适合任务量不大的情况。
SyncTaskExecutor同步执行器，任务在调用线程中直接执行，不创建新线程。无异步处理能力，适用于简单同步操作。
ConcurrentTaskExecutor包装类，允许任何实现了java.util.concurrent.Executor的实现作为Spring的TaskExecutor。提供了对现有Executor实现的适配。
ThreadPoolTaskExecutor功能丰富的线程池实现，允许配置核心线程数、最大线程数、队列容量等。适合需要精细控制线程池参数的场合。
WorkManagerTaskExecutor适用于Java EE环境下的CommonJ规范在WebLogic和WebSphere等应用服务器上有CommonJ 的 WorkManager支持时使用
TaskExecutorAdapter适配器，允许将实现了java.util.concurrent.ExecutorService的对象转换为Spring的TaskExecutor。为现有的ExecutorService提供Spring的TaskExecutor接口适配。

接下来我们重点看ThreadPoolTaskExecutor和SimpleAsyncTaskExecutor(@Async)

SpringBoot默认线程池

SpringBoot默认的线程池就是ThreadPoolTaskExecutor，但是在SpringBoot不同版本是有区别的，下面先从这个关键的TaskExecutionAutoConfiguration说起

TaskExecutionAutoConfiguration（SpringBoot 2.1后）

/*** EnableAutoConfiguration Auto-configuration for TaskExecutor.** @author Stephane Nicoll* @author Camille Vienot* @since 2.1.0*/// 仅在类 ThreadPoolTaskExecutor 存在于 classpath 时才应用
@ConditionalOnClass(ThreadPoolTaskExecutor.class)
@Configuration
// 确保前缀为 spring.task.execution 的属性配置项被加载到 bean TaskExecutionProperties 中
@EnableConfigurationProperties(TaskExecutionProperties.class)
public class TaskExecutionAutoConfiguration {/*** Bean name of the application TaskExecutor.*/public static final String APPLICATION_TASK_EXECUTOR_BEAN_NAME = "applicationTaskExecutor";private final TaskExecutionProperties properties;private final ObjectProvider<TaskExecutorCustomizer> taskExecutorCustomizers;private final ObjectProvider<TaskDecorator> taskDecorator;public TaskExecutionAutoConfiguration(TaskExecutionProperties properties,ObjectProvider<TaskExecutorCustomizer> taskExecutorCustomizers,ObjectProvider<TaskDecorator> taskDecorator) {this.properties = properties;this.taskExecutorCustomizers = taskExecutorCustomizers;this.taskDecorator = taskDecorator;}// 定义 bean TaskExecutorBuilder taskExecutorBuilder// 这是一个 TaskExecutor 构建器@Bean// 仅在该 bean 尚未被定义时才定义@ConditionalOnMissingBeanpublic TaskExecutorBuilder taskExecutorBuilder() {TaskExecutionProperties.Pool pool = this.properties.getPool();TaskExecutorBuilder builder = new TaskExecutorBuilder();builder = builder.queueCapacity(pool.getQueueCapacity());builder = builder.corePoolSize(pool.getCoreSize());builder = builder.maxPoolSize(pool.getMaxSize());builder = builder.allowCoreThreadTimeOut(pool.isAllowCoreThreadTimeout());builder = builder.keepAlive(pool.getKeepAlive());builder = builder.threadNamePrefix(this.properties.getThreadNamePrefix());builder = builder.customizers(this.taskExecutorCustomizers);builder = builder.taskDecorator(this.taskDecorator.getIfUnique());return builder;}// 懒惰模式定义 bean ThreadPoolTaskExecutor applicationTaskExecutor，// 基于容器中存在的  TaskExecutorBuilder@Lazy// 使用bean名称 : taskExecutor, applicationTaskExecutor@Bean(name = { APPLICATION_TASK_EXECUTOR_BEAN_NAME,AsyncAnnotationBeanPostProcessor.DEFAULT_TASK_EXECUTOR_BEAN_NAME })// 仅在容器中不存在类型为 Executor 的 bean 时才定义            @ConditionalOnMissingBean(Executor.class)public ThreadPoolTaskExecutor applicationTaskExecutor(TaskExecutorBuilder builder) {return builder.build();}}

注意上面的源码注释，我们可以看到@since 2.1.0，所以TaskExecutionAutoConfiguration是SpringBoot2.1以后才有的，那么这个类有啥作用呢？

TaskExecutionAutoConfiguration 是 Spring Boot 提供的一个自动配置类，它的目的是简化 Spring 应用中异步任务执行和任务调度的配置。

主要作用

  1. 自动配置异步任务执行器（Executor）： TaskExecutionAutoConfiguration 会为应用配置一个默认的 ThreadPoolTaskExecutor，这是一个基于线程池的 TaskExecutor 实现。它适用于应用中通过 @Async 注解标注的异步方法的执行。如果你不提供自定义配置，Spring Boot 将会使用这个自动配置的执行器来执行异步任务。
  2. 自动配置任务调度器（Scheduler）： 同样地，它也为应用配置一个默认的 ThreadPoolTaskScheduler，这是用于任务调度的组件，支持 @Scheduled 注解标注的方法。这个调度器允许你在应用中简便地安排定期执行的任务。
  3. 可通过应用配置文件来定制配置： TaskExecutionAutoConfiguration 支持通过 application.properties 或 application.yml 配置文件来自定义任务执行和调度的相关参数，例如线程池大小、队列容量等。这些参数分别位于 spring.task.execution 和 spring.task.scheduling 命名空间下。

优势

  • 简化配置：无需手动定义 Executor 或 Scheduler 的Bean，大大减少了样板代码。
  • 易于定制：通过配置文件即可调整线程池参数，而无需修改代码。
  • 与 Spring 生态系统的集成：自动配置的执行器和调度器与 Spring 的 @Async 和 @Scheduled 注解无缝集成。

使用场景

当你的应用需要执行异步任务或者按计划执行某些作业时，你通常会需要配置一个任务执行器或者任务调度器。在 Spring Boot 应用中，TaskExecutionAutoConfiguration 让这一步骤变得极为简单和自动化。

如果没有它

如果没有 TaskExecutionAutoConfiguration，你需要手动配置线程池、异步执行器(TaskExecutor)和任务调度器(TaskScheduler)。即，你需要在你的 Spring 配置中显式地定义相关的Bean，并可能还要为这些Bean提供自定义的配置。

总结起来，TaskExecutionAutoConfiguration 通过自动配置和简化配置工作，大大提高了开发效率，允许开发者更加专注于业务逻辑编写，而无需担心底层线程池和执行器的配置。

2.1版本以后

2.1版本后有TaskExecutionAutoConfiguration自动配置类，会帮我们自动配置默认线程池ThreadPoolTaskExecutor

线程池默认参数如下：

  • 核心线程数 (corePoolSize): 8

  • 最大线程数 (maxPoolSize): Integer.MAX_VALUE (无限制)

  • 队列容量 (queueCapacity): Integer.MAX_VALUE (无限制)

  • 空闲线程保留时间 (keepAliveSeconds): 60秒

  • 线程池拒绝策略 (RejectedExecutionHandler): AbortPolicy（默认策略，超出线程池容量和队列容量时抛出RejectedExecutionException异常）

这些参数可以通过在application.properties或application.yml文件中设置来进行自定义调整。例如：

# 核心线程数，默认为8
spring.task.execution.pool.core-size
# 最大线程数，默认为Integer.MAX_VALUE
spring.task.execution.pool.max-size
# 任务等待队列容量，默认为Integer.MAX_VALUE
spring.task.execution.pool.queue-capacity
# 空闲线程等待时间，默认为60s。如果超过这个时间没有任务调度，则线程会被回收
spring.task.execution.pool.keep-alive
# 是否允许回收空闲的线程，默认为true
spring.task.execution.pool.allow-core-thread-timeout
# 线程名前缀
spring.task.execution.thread-name-prefix=task-

如何查看参数

在 Spring Boot 中，默认的线程池由 TaskExecutorBuilder 类负责创建，它通常使用 ThreadPoolTaskExecutor 来配置默认的线程池。虽然默认的线程池参数可以根据不同的 Spring Boot 版本或特定配置而有所不同，但通常情况下，Spring Boot 默认的线程池参数如下：

在org.springframework.boot.autoconfigure.task包的TaskExecutionAutoConfiguration.java是SpringBoot默认的任务执行自动配置类。
从@EnableConfigurationProperties(TaskExecutionProperties.class)可以知道开启了属性绑定到TaskExecutionProperties.java的实体类上
img
打个断点可以看到默认参数如下：
在这里插入图片描述

进入到TaskExecutionProperties.java类中，看到属性绑定以spring.task.execution为前缀。默认线程池的核心线程数coreSize=8，最大线程数maxSize = Integer.MAX_VALUE，以及任务等待队列queueCapacity = Integer.MAX_VALUE
因为Integer.MAX_VALUE的值为2147483647(2的31次方-1)，所以默认情况下，一般任务队列就可能把内存给堆满了。我们真正使用的时候，还需要对异步任务的执行线程池做一些基础配置，以防止出现内存溢出导致服务不可用的问题。

img

方式一：通过@Async注解–采用ThreadPoolTaskExecutor

determineAsyncExecutor-查找决定使用哪个线程池

我们的@Async会默认使用什么线程池呢？这里就涉及源码了，核心源码如下：org.springframework.aop.interceptor.AsyncExecutionAspectSupport#determineAsyncExecutor

这段方法的核心作用是，根据@Async注解和方法上是否有指定的限定符来决定一个方法应该使用哪个AsyncTaskExecutor来执行异步任务。

  • 方法首先尝试从一个缓存(this.executors)中查找并返回已经与方法关联的执行器。

  • 如果缓存里没有，那么这个方法会尝试根据方法上的@Async注解中指定的限定符，从Spring应用程序上下文中查找对应的执行器。（比如@Async("taskExecutor")就会去找程序中已有的定义好的name="taskExecutor"的Bean）

  • 如果没有指定限定符或找不到对应的Bean，它将尝试使用或创建一个默认的执行器。

    • 如果是SpringBoot2.1以后，就会创建TaskExecutionAutoConfiguration帮我们自动配置好的默认线程池ThreadPoolTaskExecutor
    • 如果是SpringBoot2.1之前，TaskExecutionAutoConfiguration没有帮我们配置默认线程池，最终会找到org.springframework.core.task.SimpleAsyncTaskExecutor

  • 创建或确定执行器后，方法会将其存进缓存中，以备下次执行同一方法时使用。

protected AsyncTaskExecutor determineAsyncExecutor(Method method) {// 尝试从缓存中获取已确定的执行器AsyncTaskExecutor executor = this.executors.get(method);if (executor == null) {Executor targetExecutor; // 声明一个目标执行器String qualifier = getExecutorQualifier(method); // 获取方法上的@Async注解中指定的执行器的限定名// 如果注解中有限定名则尝试根据该名字从BeanFactory中查找对应的执行器if (StringUtils.hasLength(qualifier)) {targetExecutor = findQualifiedExecutor(this.beanFactory, qualifier);}else {// 如果未指定限定名，则使用默认的执行器targetExecutor = this.defaultExecutor;// 如果默认执行器为空，则尝试从BeanFactory中获取默认的执行器if (targetExecutor == null) {synchronized (this.executors) {// 双重检查锁定，确保只有一个线程可以初始化defaultExecutorif (this.defaultExecutor == null) {this.defaultExecutor = getDefaultExecutor(this.beanFactory);}targetExecutor = this.defaultExecutor;}}}// 如果没有合适的目标执行器，返回nullif (targetExecutor == null) {return null;}// 如果目标执行器是AsyncListenableTaskExecutor则直接使用，否则使用适配器封装以确保它实现了AsyncListenableTaskExecutor//所以SpringBoot2.1之前最终会找到org.springframework.core.task.SimpleAsyncTaskExecutorexecutor = (targetExecutor instanceof AsyncListenableTaskExecutor ?(AsyncListenableTaskExecutor) targetExecutor : new TaskExecutorAdapter(targetExecutor));// 将确定的执行器放入缓存，以便下次直接使用this.executors.put(method, executor);}// 返回确定的AsyncTaskExecutorreturn executor;
}

这个方法首先查找类型为 TaskExecutor 的Bean，如果有多个此类型的Bean，然后尝试查找名称为 “taskExecutor” 的Bean。如果这两种方式都没找到，那么将返回 null，表示没有找到适当的Bean来执行异步任务。这种情况下，AsyncExecutionInterceptor 将不会有执行器来处理异步方法。

// 会去 Spring 的容器中找有没有 TaskExecutor 或名称为 'taskExecutor' 为 Executor 的 @Nullableprotected Executor getDefaultExecutor(@Nullable BeanFactory beanFactory) {if (beanFactory != null) {try {return beanFactory.getBean(TaskExecutor.class);} catch (NoUniqueBeanDefinitionException ex) {return beanFactory.getBean("taskExecutor", Executor.class);} catch (NoSuchBeanDefinitionException ex) {return beanFactory.getBean("taskExecutor", Executor.class);}}return null;}
实操
@Service
public class SyncService {@Asyncpublic void testAsync1() {System.out.println(Thread.currentThread().getName());ThreadUtil.sleep(10, TimeUnit.DAYS);}@Asyncpublic void testAsync2() {System.out.println(Thread.currentThread().getName());ThreadUtil.sleep(10, TimeUnit.DAYS);}
}

注意需要在启动类上需要添加@EnableAsync注解，否则不会生效。

@RestController
public class TestController {@AutowiredSyncService syncService;@SneakyThrows@RequestMapping("/testSync")public void testTomcatThreadPool() {syncService.testAsync1();syncService.testAsync2();}
}

请求后观察控制台输出结果，打印线程名如下，说明我们这里采用的是TaskExecutionAutoConfiguration帮我们配置的默认线程池ThreadPoolTaskExecutor，就是以task-开头的

task-2
task-1
@Async注意点

  • 启动类上需要添加@EnableAsync注解

  • 注解的方法必须是public方法。

  • 注解的方法不要定义为static

  • 方法一定要从另一个类中调用，也就是从类的外部调用，类的内部调用是无效的。

Spring 基于AOP 实现了异步，因此，需要获取到容器中的代理对象才能具有异步功能。假定原对象叫obj，容器中的代理对象叫做 objproxy，在执行 fun() 会同时执行aop带来的其他方法。但是如果在fun() 中调用了 fun2()，那 fun2() 是原始的方法，而不是经过aop代理后的方法，就不会具有异步的功能。

方式二：直接注入 ThreadPoolTaskExecutor

2.1版本以后我们有TaskExecutionAutoConfiguration自动配置类，它会去配置默认的线程池，此时注入的ThreadPoolTaskExecutor就是默认的线程池

@RestController
public class TestController {@ResourceThreadPoolTaskExecutor taskExecutor; //SpringBoot2.1之前直接注入会报错@SneakyThrows@RequestMapping("/testSync")public void testTomcatThreadPool() {ThreadPoolExecutor threadPoolExecutor = taskExecutor.getThreadPoolExecutor();}
}

通过debug可以看到默认的线程池参数如下，就是我们上面介绍的

image-20240521200925922

2.1版本以前

方式一：通过@Async注解–采用SimpleAsyncTaskExecutor

最主要的就是此时我们没有TaskExecutionAutoConfiguration自动配置类，也就不会去配置默认的线程池，根据上面分析的determineAsyncExecutor方法，此时@Async会去采用默认的SimpleAsyncTaskExecutor

@Service
public class SyncService {@Asyncpublic void testAsync1() {System.out.println(Thread.currentThread().getName());ThreadUtil.sleep(10, TimeUnit.DAYS);}@Asyncpublic void testAsync2() {System.out.println(Thread.currentThread().getName());ThreadUtil.sleep(10, TimeUnit.DAYS);}
}

注意需要再启动类上需要添加@EnableAsync注解，否则不会生效。

@RestController
public class TestController {@AutowiredSyncService syncService;@SneakyThrows@RequestMapping("/testSync")public void testTomcatThreadPool() {syncService.testAsync1();syncService.testAsync2();}
}

验证输出结果，确实是采用了SimpleAsyncTaskExecutor线程池：

SimpleAsyncTaskExecutor-1
SimpleAsyncTaskExecutor-2

方式二：直接注入 ThreadPoolTaskExecutor

最主要的就是此时我们没有TaskExecutionAutoConfiguration自动配置类，也就不会去配置默认的线程池，此时直接注入就会报错，所以需要自己定义！

直接注入报错
@RestController
public class TestController {@ResourceThreadPoolTaskExecutor taskExecutor; //SpringBoot2.1之前直接注入会报错@SneakyThrows@RequestMapping("/testSync")public void testTomcatThreadPool() {ThreadPoolExecutor threadPoolExecutor = taskExecutor.getThreadPoolExecutor();}
}

此时发现在工程启动的时候就报错！

image-20240519225424332

解决：自定义一个线程池
@Configuration
public class ThreadPoolConfiguration {@Bean("taskExecutor")public ThreadPoolTaskExecutor taskExecutor() {ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();//设置线程池参数信息taskExecutor.setCorePoolSize(10);taskExecutor.setMaxPoolSize(50);taskExecutor.setQueueCapacity(200);taskExecutor.setKeepAliveSeconds(60);taskExecutor.setThreadNamePrefix("myExecutor--");taskExecutor.setWaitForTasksToCompleteOnShutdown(true);taskExecutor.setAwaitTerminationSeconds(60);//修改拒绝策略为使用当前线程执行taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());//初始化线程池taskExecutor.initialize();return taskExecutor;}
}

此时运行debug，可以看到不会启动报错，对应的线程池参数也是我们自定义的了

注意当我们上面自定义了线程池疑惑，@Sync对应的线程池也是我们自定义的这个，不会再采用默认的SimpleAsyncTaskExecutor

image-20240519225909829

默认的线程池好用吗？

TaskExecutionAutoConfiguration？

默认参数如下面所示：

  • 核心线程数 (corePoolSize): 8

  • 最大线程数 (maxPoolSize): Integer.MAX_VALUE (无限制)

  • 队列容量 (queueCapacity): Integer.MAX_VALUE (无限制)

  • 空闲线程保留时间 (keepAliveSeconds): 60秒

  • 线程池拒绝策略 (RejectedExecutionHandler): AbortPolicy（默认策略，超出线程池容量和队列容量时抛出RejectedExecutionException异常）

那么可能会有什么问题？

  1. 资源耗尽风险：由于最大线程数设置为Integer.MAX_VALUE，在高并发场景下，如果任务持续涌入，理论上可以创建无数线程，这将迅速消耗系统资源（如内存、CPU），可能导致服务器崩溃或极端性能下降。实际上，即使操作系统允许创建如此多的线程，这种设置也是极度不可取的。
  2. 响应性降低：虽然核心线程数设置为8是比较合理的起始点，但无限制的最大线程数意味着在高负载下，线程创建不会受限，这可能会影响到系统的响应时间和整体稳定性。过多的线程上下文切换会消耗大量CPU资源，降低处理效率。
  3. 队列无限增长：队列容量也设置为Integer.MAX_VALUE，这意味着当线程池中的线程都在忙碌且有新任务到来时，这些任务将不断堆积在队列中。如果生产速率持续高于消费速率，队列将无限增长，最终可能导致OutOfMemoryError。
  4. 异常处理策略过于简单粗暴：采用AbortPolicy作为拒绝策略，在线程池和队列都满载的情况下，新的任务提交将直接抛出RejectedExecutionException异常，而没有进行任何备份处理或降级策略，这可能会导致部分业务操作失败，且未被捕获处理的异常可能会影响到整个应用的稳定性。
  5. 缺乏灵活性和控制：对于不同的业务需求，线程池参数应当根据具体情况进行调整。例如，对响应时间敏感的服务可能需要更小的队列和更快的拒绝策略以避免任务长时间等待；而对于可延迟处理的任务，则可能需要更大的队列或不同的拒绝策略。

SimpleAsyncTaskExecutor

SimpleAsyncTaskExecutor 是Spring框架提供的一个简单的异步任务执行器，它并不是一个真正的线程池实现。它的主要特点是每次调用 #execute(Runnable) 方法时都会创建一个新的线程来执行任务。这意味着它不会重用线程，而是一次性的。

使用 SimpleAsyncTaskExecutor 可能会导致以下问题：

  1. 线程资源浪费： 每次执行任务时都创建新线程，这会导致线程的生命周期短暂，频繁地创建和销毁线程会消耗系统资源，包括CPU时间和内存。
  2. 系统资源耗尽： 在高并发场景下，如果大量任务同时提交，SimpleAsyncTaskExecutor 可能会创建大量线程，这可能会迅速耗尽系统资源，如线程数限制和内存资源。
  3. 缺乏线程管理： 真正的线程池通常包含线程管理机制，如线程重用、线程池大小控制、任务队列管理等。SimpleAsyncTaskExecutor 缺乏这些特性，因此在面对大量并发任务时可能无法有效地管理资源。
  4. 没有任务队列： 由于 SimpleAsyncTaskExecutor 不使用任务队列，它无法有效地缓冲任务。当任务提交速度超过执行速度时，新提交的任务可能会因为没有可用的线程而立即失败。
  5. 不适合长期运行的服务： 对于需要长期运行的服务，使用 SimpleAsyncTaskExecutor 可能会导致系统不稳定，因为它没有为长期运行的任务提供稳定的线程资源。

总结： SimpleAsyncTaskExecutor可以简单地用于异步任务执行，但由于它的设计限制，一般不推荐在生产环境中使用，特别是在要求高并发或资源使用高效的场景下。在这些情况下，更推荐使用可配置、可复用线程的线程池，如ThreadPoolTaskExecutor，因为它提供了更多的灵活性、效率和控制能力。

线程池核心线程数和最大线程数设置指南

线程池参数介绍
  • 核心线程数：线程池中始终活跃的线程数量。
  • 最大线程数：线程池能够容纳同时执行的最大线程数量。
线程数设置考虑因素
  1. CPU密集型任务：依赖CPU计算的任务，如循环计算等。
  2. IO密集型任务：任务执行过程中涉及等待外部操作，如数据库读写、网络请求、磁盘读写等。
CPU密集型任务的线程数设置
  • 推荐设置：核心数 + 1。
    • 原因：避免线程切换开销，同时允许一定程度的线程中断恢复。
IO密集型任务的线程数设置
  • 推荐设置：2 * CPU核心数。
    • 原因：IO操作期间，CPU可执行其他线程任务，提高资源利用率。
实际应用中的线程数计算
  • 使用工具（如Java的Visual VM）来监测线程的等待时间和运行时间。
  • 计算公式：（线程等待时间 / 线程总运行时间）+ 1 * CPU核心数。
生产环境中的线程数设置
  • 理论值与实际值可能存在差异，需要通过压力测试来确定最优线程数。
  • 压力测试：调整线程数，观察系统性能，找到最优解。
线程池参数设置建议
  • 核心业务应用：核心线程数设置为压力测试后的数值，最大线程数可以适当增加。
  • 非核心业务应用：核心线程数设置较低，最大线程数设置为压力测试结果
注意事项
  • 线程数设置需根据实际业务需求和系统环境进行调整。
  • 持续监控和优化是保证系统性能的关键。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/16462.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Linux - crond任务调度、at定时任务

Linux - crond任务调度、at定时任务

1 crontab 进行-定时任务的设置 1&#xff09;概述&#xff1a; 任务调度&#xff1a;是指系统在某个时间执行的特定的命令或程序。 任务调度分类&#xff1a; 系统工作&#xff1a;有些重要的工作必须周而复始地执行。如病毒扫描等个别用户工作&#xff1a;个别用户可能希…
阅读更多...
数据库（7）——DDL表操作2

数据库（7）——DDL表操作2

添加字段 ALTER TABLE 表名 ADD 字段名 类型 [COMMENT 注释] [约束]; 可以观察到student_information表中成功添加了名为“class”的字段。 修改字段 修改数据类型 ALTER TABLE 表名 MODIFY 字段名 新数据类型&#xff08;长度&#xff09;; 修改字段名和字段类型 ALTER TABLE…
阅读更多...
【机器学习与实现】支持向量机SVM

【机器学习与实现】支持向量机SVM

目录 一、SVM (Support Vector Machine) 概述&#xff08;一&#xff09;支持向量机SVM的主要特点&#xff08;二&#xff09;支持向量与间隔最大化&#xff08;三&#xff09;线性可分/不可分&#xff08;四&#xff09;软间隔 (soft margin) 与核技巧 (kernel trick)&#xf…
阅读更多...
5.21数据库mySQL

5.21数据库mySQL

服务器存储信息的能力是有限的&#xff0c;需要将信息存储在磁盘上。 存在主要是两个问题&#xff0c;就是将数据从磁盘中读出数据来&#xff0c;将数据从服务器中存储到磁盘上。 那么接下来的问题就是如何对于数据进行存储方便于进行读取&#xff0c;数据库就是起这样的作用…
阅读更多...
C++_C++11的学习

C++_C++11的学习

1. 统一的列表初始化 1.1&#xff5b;&#xff5d;初始化 在C98 中&#xff0c;标准就已经允许使用花括号 {} 对数组或者结构体元素进行统一的列表初始值设定。而到了C11&#xff0c;标准扩大了用大括号括起的列表 ( 初始化列表 )的使用范围&#xff0c;使其能适用于所有的内…
阅读更多...
Python 获取当前IP地址（爬虫代理）

Python 获取当前IP地址（爬虫代理）

Python 获取当前IP地址&#xff08;爬虫代理&#xff09; 在Python中&#xff0c;获取当前的公网IP地址通常涉及到发送一个请求到外部服务&#xff0c;因为本地IP地址通常只在你的私有网络内部是可见的&#xff0c;而公网IP地址是由你的ISP&#xff08;互联网服务提供商&#x…
阅读更多...
Java进阶学习笔记28——StringJoiner

Java进阶学习笔记28——StringJoiner

Java中&#xff0c;有没有即能高效&#xff0c;又能实现更方便的拼接呢&#xff1f; StringJoiner&#xff1a; JDK8才开始的&#xff0c;跟StringBuilder一样&#xff0c;也是用来操作字符串的&#xff0c;也可以看成是一个容器&#xff0c;创建之后里面的内容是可变的。 好…
阅读更多...
SpringBoot学习小结之RocketMQ

SpringBoot学习小结之RocketMQ

文章目录 前言一、架构设计1.1 架构图1.2 消息1.3 工作流程 二、部署2.1 单机2.2 集群 三、Springboot Producter3.1 准备3.2 pom依赖、yml 配置3.3 普通消息3.4 顺序、批量、延迟消息3.5 事务消息 四、Springboot Consumer4.1 配置4.2 普通Push消费4.3 回复4.4 集群和广播4.5 …
阅读更多...
在Windows中安装Redis

在Windows中安装Redis

一、下载Redis github链接&#xff1a;https://github.com/redis-windows/redis-windows/releases 二、安装 解压后点击start.bat文件即可启动服务 新开一个cmd窗口进入安装了Redis的文件夹输入redis-cli.exe -h 127.0.0.1 -p 6379连接Redis&#xff0c;见如下结果便是成功&…
阅读更多...
sql-labs靶场环境搭建（手把手保姆级教学）

sql-labs靶场环境搭建（手把手保姆级教学）

文章目录 一、sql-labs靶场简介&#xff1a;二、搭建过程1、资源下载2、配置文件&#xff1b;3、访问网站4、创建数据库 三、使用PhpStudy2018原因 一、sql-labs靶场简介&#xff1a; SQL-Labs 是一个实践环境&#xff0c;旨在用于数据库和 SQL&#xff08;结构化查询语言&…
阅读更多...
某大型制造集团企业信息化建设总体规划设计方案(67页PPT)

某大型制造集团企业信息化建设总体规划设计方案(67页PPT)

方案介绍&#xff1a; 随着信息技术的飞速发展&#xff0c;企业信息化建设已成为提高管理效率、增强企业竞争力的重要手段。某大型制造集团为应对市场变化、提升管理水平、优化资源配置&#xff0c;决定进行全面深入的信息化建设。本方案旨在构建一个集生产、管理、销售、物流…
阅读更多...
【DevOps】Jenkins + Dockerfile自动部署Maven(SpringBoot)项目

【DevOps】Jenkins + Dockerfile自动部署Maven(SpringBoot)项目

环境 docker_host192.168.0.1jenkins_host192.168.0.2 jenkins_host构建完成后把jar发布到docker_host&#xff0c;再通过dockerfile自动构建镜像&#xff0c;运行镜像 1 Jenkins安装 AWS EC2安装Jenkins&#xff1a;AWS EC2 JDK11 Jenkins-CSDN博客 AWS EC2上Docker安装…
阅读更多...
T113调试7寸RGB屏

T113调试7寸RGB屏

文章目录 软硬件介绍软件板卡屏幕 调试修改内核设备树修改U-Boot设备树 测试添加启动logo其它问题总结 软硬件介绍 软件 基于Tina5.0 SDK。 板卡 韦东山的T113工业板&#xff1a; 屏幕 韦东山的7寸RGB电容触摸屏&#xff1a; 调试 修改内核设备树 打开内核设备树<…
阅读更多...
代码随想录算法训练营第四天| 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点 、 面试题 02.07. 链表相交、142.环形链表II

代码随想录算法训练营第四天| 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点 、 面试题 02.07. 链表相交、142.环形链表II

24. 两两交换链表中的节点 题目链接&#xff1a; 24. 两两交换链表中的节点 文档讲解&#xff1a;代码随想录 状态&#xff1a;没做出来&#xff0c;没有正确更新头节点&#xff0c;因为head和cur共享引用&#xff0c;会随着cur的移动&#xff0c;丢失之前存放的节点 错误代码&…
阅读更多...
51单片机-实机演示（按键）

51单片机-实机演示（按键）

书接上回。http://t.csdnimg.cn/4wSSW 目录 一.按下灭&#xff0c;松开亮 二.两个按键控制两个灯 三.点一下灯开&#xff0c;在按一下关 四。优化按键消抖 1.加入bit变量 一.按下灭&#xff0c;松开亮 代码 #include <reg52.h> //此文件中定义了单片机的一些特…
阅读更多...
自定义函数python：深入解析与实操

自定义函数python：深入解析与实操

新书上架~&#x1f447;全国包邮奥~ python实用小工具开发教程http://pythontoolsteach.com/3 欢迎关注我&#x1f446;&#xff0c;收藏下次不迷路┗|&#xff40;O′|┛ 嗷~~ 目录 一、引言&#xff1a;函数的命名与规范 二、函数命名&#xff1a;遵循规范&#xff0c;易于…
阅读更多...
利用阅读APP3.0目录展示要查看的内容01

利用阅读APP3.0目录展示要查看的内容01

喜欢读电子书的小伙伴往往会遇到一个问题&#xff0c;就是想要看书中某些内容&#xff0c;但是不知道具体章节&#xff0c;所以就用查找功能来查&#xff0c;但是呢查找功能查出来展示的结果并不直观。 比如想要阅读:青竹蜂云剑&#xff0c;大衍决&#xff0c;南宫婉&#xff0…
阅读更多...
265 基于matlab的粒子群优化分数阶灰色预测模型

265 基于matlab的粒子群优化分数阶灰色预测模型

基于matlab的粒子群优化分数阶灰色预测模型&#xff0c;以误差结果为目标进行预测&#xff0c;输出多个预测结果。并输出迭代曲线。程序已调通&#xff0c;可直接运行。 265 分数阶灰色预测 粒子群优化算法 - 小红书 (xiaohongshu.com)
阅读更多...
二叉树——经典练习题

二叉树——经典练习题

目录 前言&#xff1a; 一、单值二叉树 题目描述&#xff1a; 思路分析&#xff1a; 代码实现&#xff1a; 二、二叉树最大深度 题目描述&#xff1a; 思路分析&#xff1a; 代码实现&#xff1a; 三、检查两颗树是否相同 题目描述&#xff1a; 思路分析&#xff1a; 代…
阅读更多...
mac电脑用n切换node版本

mac电脑用n切换node版本

一、安装 node版本管理工具 “n” sudo npm install -g n二、检查安装成功&#xff1a; n --version三、查看依赖包的所有版本号 比如: npm view webpack versions --json npm view 依赖包名 versions --json四、安装你需要的版本的node sudo n <node版本号> // 例如…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023