广州app定制开发/香港seo公司

    不管是阿里，还是华为java开发手册，都会有一条建议，就是让开发者不要使用Executors去创建线程池，而是使用构造函数ThreadPoolExecutor的方式来创建，并设置合理的参数。原因如下：

     说明：Executors 返回的线程池对象的弊端如下：
1） FixedThreadPool 和 SingleThreadPool：
允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2） CachedThreadPool：
允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

    在spring框架中，spring提供了ThreadPoolTaskExecutor来创建线程池，该类在spring-context包下。其实ThreadPoolTaskExecutor是对ThreadPoolExecutor的封装。

   到了springboot这里，因为引入了spring-boot-autoconfigurer，自动装配机制，在task包下，直接把ThreadPoolTaskExecutor注入到bean容器里面。所以在springboot项目中，如果要使用线程池，可以直接使用，都不用额外任何配置。

    springboot自动装配的线程池使用的配置如下：

    默认核心线程数是8个。最大线程数和等待队列都是Integer.MAX_VALUE。综合上面的介绍，默认配置的线程池其实也有OOM的风险。 

    这里使用的springboot版本是2.7.8。

   pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>org.example</groupId><artifactId>springexample</artifactId><version>1.0-SNAPSHOT</version><properties><maven.compiler.source>8</maven.compiler.source><maven.compiler.target>8</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.7.8</version></parent><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-websocket</artifactId></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>2.0.20</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId></dependency></dependencies></project>

    异步任务类：在方法上添加@Async注解，可以让他启用线程池处理异步任务。

/**    xxx co.ltd Copyright @ 2023-2023 All Rights Reserved*/package com.example.task;import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;import java.util.Random;
import java.util.concurrent.CompletableFuture;/*** 描述信息** @author Administrator* @since 2023/4/2 7:30*/
@Slf4j
@Component
public class AsyncTask {private Random random = new Random();@Asyncpublic CompletableFuture<String> doTaskOne() throws Exception {log.info("task one start.");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("task one done,cost " + (end - start) + "ms.");return CompletableFuture.completedFuture("task one done");}@Asyncpublic CompletableFuture<String> doTaskTwo() throws Exception {log.info("task two start.");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("task two done,cost " + (end - start) + "ms.");return CompletableFuture.completedFuture("task two done");}@Asyncpublic CompletableFuture<String> doTaskThree() throws Exception {log.info("task three start.");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("task three done,cost " + (end - start) + "ms.");return CompletableFuture.completedFuture("task three done");}
}

    启动类：启动类上添加注解@EnableAsync开启异步

/**    xxx co.ltd Copyright @ 2023-2023 All Rights Reserved*/package com.example;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;/*** 描述信息** @author Administrator* @since 2023/4/2 7:29*/
@SpringBootApplication
@EnableAsync
public class App {public static void main(String[] args) {SpringApplication.run(App.class, args);}
}

    测试类：

/**    xxx co.ltd Copyright @ 2023-2023 All Rights Reserved*/package com.example.task;import com.example.App;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import java.util.concurrent.CompletableFuture;/*** 描述信息** @author Administrator* @since 2023/4/2 7:34*/
@SpringBootTest(classes = {App.class})
@Slf4j
public class AsyncTaskTest {@Autowiredprivate AsyncTask asyncTask;@Testpublic void testTask() throws Exception {long start = System.currentTimeMillis();CompletableFuture<String> taskOne = asyncTask.doTaskOne();CompletableFuture<String> taskTwo = asyncTask.doTaskTwo();CompletableFuture<String> taskThree = asyncTask.doTaskThree();CompletableFuture.allOf(taskOne, taskTwo, taskThree).join();long end = System.currentTimeMillis();log.info("all task done,cost " + (end - start) + " ms");}
}

    这里设置了3个任务，默认线程池核心线程数是8个， 所以这3个任务在线程池环境中，基本都是同时运行，所以总体运行时间肯定会大于他们3各种最耗时的一个任务，小于三个任务耗时之和。

    运行这个测试用例，打印结果：

    从打印结果来看，3个任务几乎同时执行，运行结束，分别耗时：2094ms、 653ms、 1505ms，最后总耗时2129ms，符合预期。 

    这里打印的线程池前缀是task-，也是默认线程池配置。

    在springboot配置中，提供了可以配置线程池的参数：

spring:task:execution:pool:core-size: 2max-size: 5queue-capacity: 10thread-name-prefix: test-task-

   这些参数都不是我们自定义的，而是springboot配置文件中指定的参数名。所以我们可以通过yml自动提示类进行配置：

    这里也可以看出默认线程池配置核心数量是8个， 这里我们设置为2，来验证线程池工作原理。

    这里有3个任务，核心线程数是2，所以只能先执行2个任务，剩下的进入队列等待，当前面一个任务执行完成，最后一个任务才会从等待队列中进入核心线程进行执行，重新运行单元测试，打印信息如下：

    这个打印结果，刚开始任务1，2都运行，任务2完成之后，任务3开始执行。

    因为修改了线程前缀，这里打印的线程前缀是test-task-，从线程前缀 + 线程数上来看，这里最大线程数是2，因为前面设置的核心线程数就是2。

    =========================================

     相信做过springboot线程池相关的测试，可能有的人得出的结论和我这里不太一样，springboot默认线程池是SimpleAsyncTaskExecutor。这个原因呢，有两个，一个是springboot版本的原因，默认不做任何配置，一样的代码，上面运行打印的线程池前缀就是SimpleAsyncTaskExecutor。另外一个原因就是上面提到的ThreadPoolTaskExecutor在配置的时候，其实使用了一个特别的注解：@ConditionalOnMissingBean({Executor.class})，如下所示：

    这个注解的意思是，当bean容器中没有Executor.class这个实例的时候，进行配置。也即是说其他地方配置了线程器Executor，那么这个ThreadPoolTaskExecutor的bean就不会被配置。这也就是大家的结论里面spring线程池默认不是ThreadPoolTaskExecutor的原因。

    我这里通过引入spring-boot-starter-websocket依赖，然后配置websocket：

/**    xxx co.ltd Copyright @ 2023-2023 All Rights Reserved*/package com.example.config;import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;/*** 描述信息** @author Administrator* @since 2023/4/2 20:14*/
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {@Overridepublic void registerStompEndpoints(StompEndpointRegistry registry) {registry.addEndpoint("/tmax/ws").setAllowedOriginPatterns("*").withSockJS();}@Overridepublic void configureMessageBroker(MessageBrokerRegistry registry) {registry.enableSimpleBroker("/user","/topic");registry.setApplicationDestinationPrefixes("/app");registry.setUserDestinationPrefix("/user");}
}

    同样的，我们再次测试，发现结果如下所示：

    这里也验证了上面@ConditionalOnMissingBean({Executor.class})注解的作用，因为有了别的线程池，所以这里ThreadPoolTaskExecutor线程池就没有被加载。这里的线程池就是SimpleAsyncTaskExecutor。这个线程池其实不是一个真正的线程池，因为它每次都会创建新线程，这个线程池创建的目的其实就是为了执行少量短时间的任务，并不适合在高并发场景下。

    ================================

     通过上面的实验，我们知道，在springboot 2.7.8版本里面，如果没有其他配置，默认线程池就是ThreadPoolTaskExecutor，而且可以不用任何配置就可以使用。但是它还是有OOM的风险，因为它的max-size和queue-capacity都是Integer.MAX_VALUE，所以我们需要修改它的默认线程池配置信息。但是默认线程池有个德性，就是如果配置了其他线程池，它又不会被加载。

     所以一般的项目里面，我们都是进行如下所示的手动配置：

/**    xxx co.ltd Copyright @ 2023-2023 All Rights Reserved*/package com.example.config;import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;import java.util.concurrent.ThreadPoolExecutor;/*** 描述信息** @author Administrator* @since 2023/4/2 20:36*/
@Configuration
@EnableAsync
public class ThreadPoolConfig {@Value("${spring.task.execution.pool.core-size}")private int corePoolSize;@Value("${spring.task.execution.pool.max-size}")private int maxPoolSize;@Value("${spring.task.execution.pool.queue-capacity}")private int queueCapacity;@Value("${spring.task.execution.thread-name-prefix}")private String threadNamePrefix;@Beanpublic ThreadPoolTaskExecutor taskExecutor() {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();executor.setCorePoolSize(corePoolSize);executor.setMaxPoolSize(maxPoolSize);executor.setQueueCapacity(queueCapacity);executor.setThreadNamePrefix(threadNamePrefix);// 拒绝策略executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());executor.initialize();return executor;}
}

    另外，一定要结合application.yml中设置的线程池配置信息使用，这样才符合文章开头所说的大厂java开发手册中建议使用自定义参数配置线程池，避免OOM风险。