通用线程池工具类

public class CommonExecutorManager {

    public static final String POOL_DEFAULT = "POOL_DEFAULT";

    /**
     * 线程池map
     */
    private Map<String, ExecutorService> threadPoolMap = null;

    /**
     * 默认线程池
     */
    private ExecutorService defaultExecutor = null;

    @PostConstruct
    public void init(){
        //初始化线程池map
        threadPoolMap = new HashMap<>(2);
        //构建默认线程池
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("AsyncManager-default-%d").build();
        this.defaultExecutor = new ThreadPoolExecutor(
                Runtime.getRuntime().availableProcessors(), Runtime.getRuntime().availableProcessors() * 2 + 1,
                100L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(1024), threadFactory,
                new ThreadPoolExecutor.DiscardPolicy());
        threadPoolMap.put(POOL_DEFAULT, defaultExecutor);
    }

    @PreDestroy
    public void close(){
        if (defaultExecutor != null){
            defaultExecutor.shutdown();
        }
        for (ExecutorService executorService : threadPoolMap.values()) {
            executorService.shutdown();
        }
    }

    /**
     * 异步执行supplier
     * @param poolName  线程池
     * @param supplier  supplier
     * @param <T>       结果类型
     * @return
     */
    public <T> CompletableFuture<T> supplyAsync(String poolName, Supplier<T> supplier){
        if (poolName == null){
            poolName = POOL_DEFAULT;
        }
        ExecutorService executorService = threadPoolMap.getOrDefault(poolName, defaultExecutor);
        return CompletableFuture.supplyAsync(supplier, executorService);
    }

    /**
     * 并发执行supplier，并等待结束
     * @param poolName
     * @param supplierList
     * @param <T>
     * @return
     */
    public <T> List<T> supplyListSync(String poolName, List<Supplier<T>> supplierList){
        if (poolName == null){
            poolName = POOL_DEFAULT;
        }
        ExecutorService executorService = threadPoolMap.getOrDefault(poolName, defaultExecutor);
        List<CompletableFuture<T>> futureList = supplierList.stream().map(supplier -> CompletableFuture.supplyAsync(supplier, executorService))
                .collect(Collectors.toList());
        return futureList.stream()
                .map(CompletableFuture::join).collect(Collectors.toList());
    }

    /**
     * 查询线程池
     * @param poolName
     * @return
     */
    public ExecutorService getExecutorByName(String poolName){
        return threadPoolMap.getOrDefault(poolName, defaultExecutor);
    }

    /**
     * 创建普通线程池
     * @param coreSize  核心线程数
     * @param maxSize   最大线程数
     * @param threadName    线程名称
     * @param daemon    是否为守护线程
     * @return
     */
    public static ExecutorService createThreadPool(int coreSize, int maxSize, String threadName, boolean daemon){
        ThreadPoolExecutor executor = new ThreadPoolExecutor(coreSize, maxSize, 5, TimeUnit.MINUTES, new LinkedBlockingQueue<>(),
                new ThreadFactoryBuilder().setNameFormat(threadName + "-%d").setDaemon(daemon).build());
        return executor;
    }

    /**
     * 创建定时线程池
     * @param nThreads
     * @param threadName
     * @return
     */
    public static ScheduledThreadPoolExecutor createScheduledPool(int nThreads, String threadName) {
        return new ScheduledThreadPoolExecutor(nThreads, new ThreadFactoryBuilder().setNameFormat(threadName + "-%d").build());
    }

    /**
     * 创建可缓存的线程池
     * @param threadFactory
     * @return
     */
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>(), threadFactory);
    }
}