springboot线程池+等待结束+ThreadPoolTaskExecutor

配置类

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.Executor;
import java.util.concurrent.ThreadPoolExecutor;

@EnableAsync    // 启用 Spring 的异步方法执行功能
@Configuration
public class ExecutorConfig {


    // new ThreadPoolTaskExecutor();
    /**
     * 核心线程数量，默认1
     */
    private int corePoolSize = 6;

    /**
     * 最大线程数量，默认Integer.MAX_VALUE;
     */
    private int maxPoolSize = 6;

    /**
     * 空闲线程存活时间
     */
    private int keepAliveSeconds = 60;

    /**
     * 线程阻塞队列容量,默认Integer.MAX_VALUE
     */
    private int queueCapacity = 1;

    /**
     * 是否允许核心线程超时
     */
    private boolean allowCoreThreadTimeOut = false;


    @Bean("asyncExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 配置核心线程数量
        executor.setCorePoolSize(corePoolSize);
        // 配置最大线程数
        executor.setMaxPoolSize(maxPoolSize);
        // 配置队列容量
        executor.setQueueCapacity(queueCapacity);
        // 配置空闲线程存活时间
        executor.setKeepAliveSeconds(keepAliveSeconds);

        executor.setAllowCoreThreadTimeOut(allowCoreThreadTimeOut);

        // 设置拒绝策略，直接在execute方法的调用线程中运行被拒绝的任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        // 执行初始化
        executor.initialize();
        return executor;
    }
}

Service

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import org.springframework.ui.context.Theme;

import java.util.Random;
import java.util.concurrent.Future;

@Service
@Slf4j
public class AsyncService {

    @Async("asyncExecutor")
    public Future<String> executeAsync(int a) {
        String msg = "500";
        try {
            Thread.sleep(a * 1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+":我已经输出了");

        return new AsyncResult<String>(msg);
    }
}

Controller

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.Future;

@Slf4j
@RestController
public class ThreadTest {
    @Autowired
    private AsyncService asyncService;

    // http://localhost:8080/threadTest
    @GetMapping("threadTest")
    public String OJ() {

        Future<String> s1 = asyncService.executeAsync(1);
        Future<String> s2 = asyncService.executeAsync(2);
        Future<String> s3 = asyncService.executeAsync(3);
        Future<String> s4 = asyncService.executeAsync(4);
        Future<String> s5 = asyncService.executeAsync(5);
        Future<String> s6 = asyncService.executeAsync(6);
        Future<String> s7 = asyncService.executeAsync(7);
        while (!(s1.isDone() && s2.isDone() && s3.isDone() && s4.isDone())) {
            try {
                Thread.sleep(1000);
                System.out.println("还没运行完毕");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("运行结束");
        return "ssss";
    }
}