springboot 线程池学习

最近闲下来看了springboot 线程池的使用，也许今后会用到。
定义线程池

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
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;

@SpringBootApplication
public class MyspringbootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyspringbootApplication.class, args);
    }
    @EnableAsync
    @Configuration
    class TaskPoolConfig {

        /**
         * 核心线程数10：线程池创建时候初始化的线程数
         * 最大线程数20：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
         * 缓冲队列200：用来缓冲执行任务的队列
         * 允许线程的空闲时间60秒：当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
         * 线程池名的前缀：线程名称前缀，方便我们查找区分  myTaskPool-1、myTaskPool-2  这样
         * 线程池对拒绝任务的处理策略：这里采用了CallerRunsPolicy策略，当线程池没有处理能力的时候，该策略会直接在 execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务
         */
        @Bean("myTaskPool")
        public Executor taskExecutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(10);
            executor.setMaxPoolSize(20);
            executor.setQueueCapacity(200);
            executor.setKeepAliveSeconds(60);
            executor.setThreadNamePrefix("myTaskPool-");
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            return executor;
        }
    }

然后是使用：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;

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

/**
 * @Auther: Administrator
 * @Date: 2018/11/5 14:39
 * @Description:
 */
@Component
public class TestTask {
    public static Random random = new Random();
    Logger logger = LoggerFactory.getLogger(getClass());
    @Async("myTaskPool")
    public Future<String> doTaskOne() throws Exception {
        logger.info("开始做任务一");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        logger.info("完成任务一，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务一完成");
    }

    @Async("myTaskPool")
    public Future<String> doTaskTwo() throws Exception {
        logger.info("开始做任务二");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        logger.info("完成任务二，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务二完成");
    }

    @Async("myTaskPool")
    public Future<String> doTaskThree() throws Exception {
        logger.info("开始做任务三");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        logger.info("完成任务三，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务三完成");
    }

通过异步注解@Async 使用线程池，需要写入线程池的名字,然后运行：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.concurrent.Future;

/**
 * @Auther: Administrator
 * @Date: 2018/11/5 14:44
 * @Description:
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTest {
    @Autowired
    private TestTask task;

    @Test
    public void test() throws Exception {

        Future<String> task1 = task.doTaskOne();
        Future<String> task2 = task.doTaskTwo();
        Future<String> task3 = task.doTaskThree();
        while(true) {
            if(task1.isDone() && task2.isDone() && task3.isDone()) {
                // 三个任务都调用完成，退出循环等待
                break;
            }
            Thread.sleep(1000);
        }
        //等待子线程结束
//        Thread.currentThread().join();
        System.out.println("子线程执行完毕");
    }

Future对象获取线程的结果，不然主线程会开启完线程后直接退出，日志什么都看不到
下面是执行结果

更新：
真的用到，同时用CompletableFuture对象小小的升级了一下，jdk要求最低1.8。
公司有个并发请求相同接口的需求,服务A通过feign传过来一个数组名单，其中每一个名字都要通过相同接口拿到一个返回值。遍历就太慢了，名单最多会有20+，其中myApi.getPrice(name,typeCode) 需要被多线程并发，只是一个普通的请求就不展开了，具体实现如下:

public RetEntity<List<MaintainInfoDTO>> getMaintain(@RequestParam("typecode") String typeCode, @RequestParam("partnames") String[] partNames) throws Exception {
        RetEntity<List<MaintainInfoDTO>> ret = new RetEntity<>();
        List<String> nameList = Arrays.asList(partNames).stream().filter(a->CommonUtil.isNotEmpty(a)&&!a.equals("null")).collect(toList());

        Executor executor = Executors.newFixedThreadPool(Math.min(nameList.size(), 20),//执行器个数，和需请求次数相同。最大20
            new ThreadFactory() {
                @Override
                public Thread newThread(Runnable r) {
                    Thread thread = new Thread(r);
                    //使用守护线程,使用这种方式不会组织程序的关停
                    thread.setDaemon(true);
                    return thread;
                }
            }
        );
        List<CompletableFuture<MaintainInfoDTO>> futures = nameList.stream()
            .map(a -> CompletableFuture.supplyAsync(()->myApi.getPrice(a,typeCode),executor)).collect(toList());
		//上面是调用和拿到开始执行对象的list，其实并没有执行完毕
        List<MaintainInfoDTO> list = futures.stream()
            .map(CompletableFuture::join)
            .collect(toList());
            //这里就是已完成并取出返回值的list了
        ret.initRetList(list);
        return ret;
    }