单例线程池工具类

<dependency>
   <groupId>org.apache.skywalking</groupId>
   <artifactId>apm-toolkit-trace</artifactId>
   <version>xxx</version>
</dependency>

/**
 * 线程池
 * <br>
 * 重写execute和submit方法，传递traceId
 * 方法都是原生ThreadPoolExecutor方法，不做多解释
 *
 */
public class ThreadPoolExecutor extends java.util.concurrent.ThreadPoolExecutor {

    //参数初始化
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    //核心线程数量大小
    private static final int corePoolSize = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    //线程池最大容纳线程数( IO密集型读写较多的配置)
    private static final int iomaximumPoolSize = CPU_COUNT * 2;
    //线程池最大容纳线程数( CPU密集型计算较多的配置)
    private static final int cpumaximumPoolSize = CPU_COUNT + 1;
    //线程空闲后的存活时长
    private static final long keepAliveTime = 30L;
    //阻塞队列长度
    private static final int queueLength = 100;

    public static ExecutorService iocachedThreadPool = null;
    public static ExecutorService cpucachedThreadPool = null;
    public static ScheduledExecutorService scheduledThreadPool = null;

    /**
     * 创建一个IO密集型读写较多的线程池，该线程池根据需要创建新线程，但在以前构建的线程可用时将重用这些线程.
     * 如果没有可用的现有线程，则将创建线程并将其添加到池中。若同时执行的的任务超过最大线程(CPU_COUNT * 2)会抛异常
     * 具有30秒内未使用的将被终止。因此，一个足够长时间闲置的池将不消耗任何资源。
     *
     * @return 返回新创建的线程池
     */
    public static ExecutorService newIOCachedThreadPool() {
        if (iocachedThreadPool == null) {
            synchronized (ThreadPoolExecutor.class) {
                if (iocachedThreadPool == null) {
                    iocachedThreadPool = new java.util.concurrent.ThreadPoolExecutor(corePoolSize, iomaximumPoolSize,
                            60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(queueLength));
                }
            }
        }
        return iocachedThreadPool;
    }

    /**
     * 创建一个CPU密集型计算较多的线程池，该线程池根据需要创建新线程，但在以前构建的线程可用时将重用这些线程.
     * 如果没有可用的现有线程，则将创建线程并将其添加到池中。若同时执行的的任务超过最大线程(CPU_COUNT + 1)会抛异常
     * 具有30秒内未使用的将被终止。因此，一个足够长时间闲置的池将不消耗任何资源。
     *
     * @return 返回新创建的线程池
     */
    public static ExecutorService newCPUCachedThreadPool() {
        if (cpucachedThreadPool == null) {
            synchronized (ThreadPoolExecutor.class) {
                if (cpucachedThreadPool == null) {
                    cpucachedThreadPool = new ThreadPoolExecutor(corePoolSize, cpumaximumPoolSize,
                            keepAliveTime, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(queueLength));
                }
            }
        }
        return cpucachedThreadPool;
    }

    /**
     * 创建一个线程池，该线程池可以安排命令在给定延迟后运行，或定期执行。
     *
     * @return 返回新创建的线程池
     */
    public static ScheduledExecutorService newScheduledThreadPool() {
        if (scheduledThreadPool == null) {
            synchronized (ThreadPoolExecutor.class) {
                if (scheduledThreadPool == null) {
                    scheduledThreadPool = Executors.newScheduledThreadPool(cpumaximumPoolSize);
                }
            }
        }
        return scheduledThreadPool;
    }

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    }

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }

    @Override
    public void execute(Runnable task) {
        super.execute(task);
        //super.execute(RunnableWrapper.of(task));
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        return super.submit(task);
        //return super.submit(CallableWrapper.of(task));
    }

    @Override
    public Future<?> submit(Runnable task) {
        return super.submit(task);
        //return super.submit(RunnableWrapper.of(task));
    }

}