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包

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>thread-pool-dome</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>thread-pool-dome</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

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

线程名称不一样了，而且不是顺序的，则说明成功了