多线程之--线程池使用

    private final static ArrayBlockingQueue<Runnable> WORK_QUEUE = new ArrayBlockingQueue<>(9);

    private final static RejectedExecutionHandler HANDLER = new ThreadPoolExecutor.CallerRunsPolicy();
    private static ThreadPoolExecutor executorService = new ThreadPoolExecutor(16, 16, 1000, TimeUnit.MILLISECONDS, WORK_QUEUE, HANDLER);

    public SysUserDTO getSysUser() {
        SysUserDTO sysUserDTO = new SysUserDTO();
        try {
            RequestAttributes attributes = RequestContextHolder.getRequestAttributes();


            //多线程查询国家
            Callable<List> countryListCallable = () -> {
                //向子线程中塞入父线程请求头信息(仅用于父等待子线程返回; 
                //若父线程先结束,子线程header里面的值将会丢失,此方式不在适用)
                RequestContextHolder.setRequestAttributes(attributes);
                return basicCountryService.getUserCountryByAccount(CommonConstants.ALL);
            };
            FutureTask<List> menuListTask = new FutureTask<>(countryListCallable);
            executorService.submit(menuListTask);

            List list = menuListTask.get();

        } catch (Exception e) {
            log.error(Throwables.getStackTraceAsString(e));
        }
        return sysUserDTO;
    }

        //创建线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 10, 30, TimeUnit.SECONDS, new SynchronousQueue<>());
        //向线程池提交任务 无返回值
        threadPoolExecutor.execute(new Runnable() {
            @Override
            public void run() {
 
            }
        });
 
        //向线程池提交任务 有返回值
        Future<String> submit = threadPoolExecutor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("threadPoolExecutor submit");
                return "null";
            }
        });
 
        //返回任务的执行结果
        try {
            Object o = submit.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //关闭线程池
        threadPoolExecutor.shutdown();
    

线程池配置

import cn.hutool.core.thread.ThreadFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池配置类
 *
 */

@Configuration
public class ThreadPoolConfig {


    @Bean("defaultThreadPool")
    public ThreadPoolExecutor getThreadPool() {
        /*
         * 核心线程数：5
         * 最大线程数：20
         * 空闲线程存活时间：5
         * 空闲线程存活时间单位：秒
         * 任务阻塞队列：有界阻塞队列,队列容量-->1024
         * 线程池工厂
         * 默认拒绝策略:除非线程池shutdown时拒绝
         */
        return new ThreadPoolExecutor(5,
                20,
                5,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1024),
                ThreadFactoryBuilder.create().build(),
                new ThreadPoolExecutor.CallerRunsPolicy());
    }
}

@Resource
private ThreadPoolExecutor threadPoolExecutor;

threadPoolExecutor.execute(new Runnable() {
    @Override
    public void run() {
       
  }
});