线程池工具类 （单例模式 枚举）

ThreadPoolUtil

package com.wuzhou.utils;

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

/**
 * 线程池 工具类 (采用枚举类型的单例模式)
 *
 * @author Y_Kevin
 * @date 2021-03-19 15:28
 */
public class ThreadPoolUtil {
    private enum innerEnum {

        INSTANCE;
        private final ThreadPoolExecutor executor;
        private final ThreadPoolUtil threadPoolUtil;

        innerEnum() {
            System.out.println("创建线程池。(只出现一次)");
            /**
             * 创建LinkedBlockingQueue，容量Integer.MAX_VALUE 。
             */
            LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
            /**
             * 拒绝策略 ： 运行被拒绝的任务
             */
            ThreadPoolExecutor.CallerRunsPolicy policy = new ThreadPoolExecutor.CallerRunsPolicy();
            /**
             * int corePoolSize : 常驻核心线程数
             * int maximumPoolSize : 线程池能够容纳同时执行的最大线程数据
             * long keepAliveTime : 线程池中的线程空闲时间，当空闲时间达到 keepAliveTime 值时，线程会被销毁，直到只剩下 corePoolSize
             * TimeUnit unit : keepAliveTime 的时间单位
             * BlockingQueue<Runnable> workQueue : 缓存队列，当请求线程数大于 corePoolSize 时，线程进入 BlockingQueue 阻塞队列
             * RejectedExecutionHandler handler : 执行拒绝策略的对象，当活动线程数大于 maximumPoolSize 的时候，线程池通过该处理策略
             */
            executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors() * 2,
                    Runtime.getRuntime().availableProcessors() * 2,
                    60L, TimeUnit.MILLISECONDS,
                    queue,
                    policy
            );
            threadPoolUtil = new ThreadPoolUtil();
        }

        private ThreadPoolExecutor getThreadPool() {
            return executor;
        }

        private ThreadPoolUtil threadPoolUtil() {
            return threadPoolUtil;
        }
    }

    /**
     * 获取实例
     */
    public static ThreadPoolUtil getInstance() {
        return innerEnum.INSTANCE.threadPoolUtil();
    }

    /**
     * 获取线程池
     */
    public ThreadPoolExecutor getThreadPool() {
        return innerEnum.INSTANCE.getThreadPool();
    }
}

使用

// 获取线程池实例
ThreadPoolExecutor executor = ThreadPoolUtil.getInstance().getThreadPool();
log.info("ThreadPoolExecutor==>" + executor);

// 执行任务并获取Future对象
List<Future<JSONObject>> futureList = executor.invokeAll(shipSortListTask);

// 结果遍历
for (Future<JSONObject> f : futureList) {
    JSONObject jsonObject = new JSONObject();
    jsonObject = f.get();
}