srpingboot 对线程池的理解与使用
1、描述
以前学过线程池，但是还是对它一知半解，今天通过网上一些资料，自己手动写了个demo，进行学习。什么叫线程池，一般执行程序是不仅仅只有一个线程，如果没有线程池，那么每次我们都有去创建一个个线程来用。但是引入线程池后，就相当于创建多个线程备用，管理线程，避免创建大量的线程增加开销。线程池的概念类似人才资源中心，原本每次要运行一个线程（公司找一个员工）都必须去创建（培养）一个员工才行，有了线程池之后就在线程池中准备了多个创建好的线程（培训好的员工）等待被调用。
git 网址：https://github.com/kinber123/Thread-pool-dome.git
2、线程池流程
（1）提交任务后，线程池先判断线程数是否达到了核心线程数（corePoolSize）。如果未达到线程数，则创建核心线程处理任务；否则，就执行下一步；
（2）接着线程池判断任务队列是否满了。如果没满，则将任务添加到任务队列中；否则，执行下一步；
（3）接着因为任务队列满了，线程池就判断线程数是否达到了最大线程数。如果未达到，则创建非核心线程处理任务；否则，就执行饱和策略，默认会抛出。
3、线程池部分参数的说明
CorePoolSize（）:
/**
* 设置线程池核心容量
* 核心线程会一直存活,即使没有任务需要处理.当线程数小于核心线程数时,
* 即使现有的线程空闲,线程池也会优先创建新线程来处理任务,而不是直接交
* 给现有的线程处理;核心线程在allowCoreThreadTimeout被设置为true时
* 会超时退出,默认情况下不会退出..
*/
MaxPoolSize():
/**
* 当线程数大于或等于核心线程,且任务队列已满时,线程池会创建新的线程,
* 直到线程数量达到maxPoolSize.如果线程数已等于maxPoolSize,且任务
* 队列已满,则已超出线程池的处理能力,线程池会拒绝处理任务而抛出异常;
*/
QueueCapacity():
/**
* 任务队列容量.从maxPoolSize的描述上可以看出,任务队列的容量会影响到线
* 程的变化,因此任务队列的长度也需要恰当的设置.我们中给了10000,相当于就
* 是没有上限了....
*/
KeepAliveSeconds():
/**
* 当线程空闲时间达到keepAliveTime,该线程会退出,直到线程数量等于corePoolSize,
* 如果allowCoreThreadTimeout设置为true,则所有线程均会退出直到线程数量为0.
*/
AllowCoreThreadTimeout():
/**
* 是否允许核心线程空闲退出,默认值为false.一般就使用false的
*/
ThreadNamePrefix():
/**
* 设置线程池 前缀
*/
WaitForTasksToCompleteOnShutdown():
/**
* 在配置了spring线程池的情况下，如果某时刻要停止应用，如果没有优雅停机，\
* 存在于线程池中的任务将会被强制停止，导致部分任务失败
* WaitForTasksToCompleteOnShutdown=true（默认为false），表明等待所有线程执行完
AwaitTerminationSeconds():
/**在配置了spring线程池的情况下，如果某时刻要停止应用，如果没有优雅停机，
* 存在于线程池中的任务将会被强制停止，导致部分任务失败
* AwaitTerminationSeconds=xx（默认为0，此时立即停止），并没等待xx秒后强制停止
*/
4、项目框架
5、pom.mxl 引入Jar包
4.0.0
org.springframework.boot
spring-boot-starter-parent
2.3.0.RELEASE
com.example
thread-pool-dome
0.0.1-SNAPSHOT
thread-pool-dome
Demo project for Spring Boot
11
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-test
test
org.junit.vintage
junit-vintage-engine
org.springframework.boot
spring-boot-maven-plugin
6、application 配置
server.servlet.context-path=/threadPool
server.port=8084
#线程池配置.
task.execution.pool.core-size=10
task.execution.pool.max-size=20
task.execution.pool.queue-capacity=200
task.execution.pool.keep-alive=60
task.execution.pool.allow-core-thread-timeout=false
task.execution.pool.thread-name-prefix=taskExecutor--
task.execution.pool.wait-for=true
task.execution.pool.await-termination-seconds=60
7、线程池配置TaskPoolConfig
这里必须有两个注解@Configuration和@EnableAsync ，@Configuration是代表这个类是个配置类，@EnableAsync是否开启异步方法支持，主要为了@Async为异步注解。
package com.example.dome.config;
import org.apache.tomcat.util.threads.ThreadPoolExecutor;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
/**
* \* @author wcy
* \* @date: 2020-06-05 14:42
* \* Description: 类
* \
*/
@Configuration
@EnableAsync
public class TaskPoolConfig implements AsyncConfigurer {
/**
* 设置线程池核心容量
* 核心线程会一直存活,即使没有任务需要处理.当线程数小于核心线程数时,
* 即使现有的线程空闲,线程池也会优先创建新线程来处理任务,而不是直接交
* 给现有的线程处理;核心线程在allowCoreThreadTimeout被设置为true时
* 会超时退出,默认情况下不会退出..
*/
@Value("${task.execution.pool.core-size}")
private int corePoolSize;
/**
* 当线程数大于或等于核心线程,且任务队列已满时,线程池会创建新的线程,
* 直到线程数量达到maxPoolSize.如果线程数已等于maxPoolSize,且任务
* 队列已满,则已超出线程池的处理能力,线程池会拒绝处理任务而抛出异常;
*/
@Value("${task.execution.pool.max-size}")
private int maxPoolSize;
/**
* 任务队列容量.从maxPoolSize的描述上可以看出,任务队列的容量会影响到线
* 程的变化,因此任务队列的长度也需要恰当的设置.我们中给了10000,相当于就
* 是没有上限了....
*/
@Value("${task.execution.pool.queue-capacity}")
private int queueCapacity;
/**
* 当线程空闲时间达到keepAliveTime,该线程会退出,直到线程数量等于corePoolSize,
* 如果allowCoreThreadTimeout设置为true,则所有线程均会退出直到线程数量为0.
*/
@Value("${task.execution.pool.keep-alive}")
private int keepAliveSeconds;
/**
* 是否允许核心线程空闲退出,默认值为false.一般就使用false的
*/
@Value("${task.execution.pool.allow-core-thread-timeout}")
private boolean allowCoreThreadTimeout;
/**
* 设置线程池 前缀
*/
@Value("${task.execution.pool.thread-name-prefix}")
private String threadNamePrefix;
/**
* 在配置了spring线程池的情况下，如果某时刻要停止应用，如果没有优雅停机，\
* 存在于线程池中的任务将会被强制停止，导致部分任务失败
* WaitForTasksToCompleteOnShutdown=true（默认为false），表明等待所有线程执行完
*/
@Value("${task.execution.pool.wait-for}")
private boolean waitForTasks;
/**在配置了spring线程池的情况下，如果某时刻要停止应用，如果没有优雅停机，
* 存在于线程池中的任务将会被强制停止，导致部分任务失败
* AwaitTerminationSeconds=xx（默认为0，此时立即停止），并没等待xx秒后强制停止
*/
@Value("${task.execution.pool.await-termination-seconds}")
private int awaitTerminationSeconds;
@Override
@Bean("taskExecutor")
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
// 设置线程池核心容量
taskExecutor.setCorePoolSize(corePoolSize);
// 设置线程池最大容量
taskExecutor.setMaxPoolSize(maxPoolSize);
// 设置任务队列长度
taskExecutor.setQueueCapacity(queueCapacity);
// 设置线程超时时间
taskExecutor.setKeepAliveSeconds(keepAliveSeconds);
// 设置线程名称前缀
taskExecutor.setThreadNamePrefix(threadNamePrefix);
// 是否允许核心线程空闲退出,默认值为false.一般就使用false的
taskExecutor.setAllowCoreThreadTimeOut(allowCoreThreadTimeout);
// 调度器shutdown被调用时等待当前被调度的任务完成
taskExecutor.setWaitForTasksToCompleteOnShutdown(waitForTasks);
// （默认为0，此时立即停止），并没等待xx秒后强制停止
taskExecutor.setAwaitTerminationSeconds(awaitTerminationSeconds);
// 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者
taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
return taskExecutor;
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return new SimpleAsyncUncaughtExceptionHandler();
}
}8、创建一个简单的功能
@Async（）注解代表这个方法是托管线程池的，taskExecutor 是对应配置的TaskPoolConfig 的@Bean里面的名称
package com.example.dome.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
/**
* \* @author wcy
* \* @date: 2020-06-05 14:45
* \* Description: 类
* \
*/
@Service
public class AsyncTaskServiceImpl implements AsyncTaskService{
private static final Logger logger = LoggerFactory.getLogger(AsyncTaskService.class);
@Override
@Async("taskExecutor")
public void intTask(int i){
try {
Thread.sleep(1000);
logger.info(Thread.currentThread().getName()+"---int--"+i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
@Async("taskExecutor")
public void stringTask(String str){
try {
Thread.sleep(2000);
logger.info(Thread.currentThread().getName()+"---string--"+str);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
package com.example.dome.service;
/**
* \* @author wcy
* \* @date: 2020-06-05 14:50
* \* Description: 接口
* \
*/
public interface AsyncTaskService {
void intTask(int i);
void stringTask(String str);
}9、创建controller 进行测试
我这里进行for 循环，但是也可以用其他方式
package com.example.dome.controller;
import com.example.dome.service.AsyncTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* \* @author wcy
* \* @date: 2020-06-05 14:52
* \* Description: 类
* \
*/
@RestController
public class TaskController {
@Autowired
private AsyncTaskService asyncTaskService;
@RequestMapping("/task")
public String task(){
for (int i =0;i<10;i++){
asyncTaskService.intTask(i);
asyncTaskService.stringTask(String.valueOf(i));
}
return null;
}
}
10、运行程序，输入网址
网址输入IP:localhost:8084/threadPool/task
线程名称不一样了，而且不是顺序的，则说明成功了
