线程池工厂

ThreadPoolFactory.getNormalPool.submit(
()->{

});

public class ThreadPoolProxy implements Executor {
    /**
     * The Constant LOGGER.
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(ThreadPoolProxy.class);

    /**
     * The m executor.
     */
    ThreadPoolExecutor mExecutor; // 只需创建一次

    /**
     * The m core pool size.
     */
    int mCorePoolSize;

    /**
     * The m maximum pool size.
     */
    int mMaximumPoolSize;

    /**
     * The m keep alive time.
     */
    long mKeepAliveTime;

    /**
     * Instantiates a new thread pool proxy.
     *
     * @param corePoolSize the core pool size
     * @param maximumPoolSize the maximum pool size
     * @param keepAliveTime the keep alive time
     * @return null
     */
    public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long keepAliveTime) {
        mCorePoolSize = corePoolSize;
        mMaximumPoolSize = maximumPoolSize;
        mKeepAliveTime = keepAliveTime;
        initThreadPoolExecutor();
    }

    /**
     * Inits the thread pool executor.
     *
     * @return the thread pool executor
     */
    private ThreadPoolExecutor initThreadPoolExecutor() {
        // 双重检查加锁
        if (mExecutor == null) {
            synchronized (ThreadPoolProxy.class) {
                if (mExecutor == null) {
                    TimeUnit unit = TimeUnit.SECONDS;
                    SynchronousQueue<Runnable> workQueue = new SynchronousQueue<Runnable>(); // 阻塞队列
                    mExecutor = new ThreadPoolExecutor( //
                        mCorePoolSize, // 核心的线程数
                        mMaximumPoolSize, // 最大的线程数
                        mKeepAliveTime, // 保持时间
                        unit, // 保持时间对应的单位
                        workQueue, // 缓存队列/阻塞队列
                        (runnable, executors) -> {
                            try {
                                executors.getQueue().put(runnable);
                            } catch (InterruptedException e) {
                                LOGGER.error("The request blocking queue is Exception={}", e);
                            }
                        });
                }
            }
        }
        return mExecutor;
    }

    /**
     * Execute.
     *
     * @param task the task
     */
    @Override
    public void execute(Runnable task) {
        mExecutor.execute(task);
    }

    /**
     * Submit task.
     *
     * @param task the task
     */
    public void submitTask(Runnable task) {
        mExecutor.submit(task);
    }

    /**
     * Submit.
     *
     * @param task the task
     * @return the future
     */
    public Future<?> submit(Runnable task) {
        return mExecutor.submit(task);
    }

    /**
     * Removes the task.
     *
     * @param task the task
     */
    public void removeTask(Runnable task) {
        mExecutor.remove(task);
    }

    /**
     * Gets the pool size.
     *
     * @return the pool size
     */
    public int getPoolSize() {
        return mExecutor.getPoolSize();
    }

    /**
     * Gets the queue size.
     *
     * @return the queue size
     */
    public int getQueueSize() {
        return mExecutor.getQueue().size();
    }

    /**
     * Gets the completed task count.
     *
     * @return the completed task count
     */
    public long getCompletedTaskCount() {
        return mExecutor.getCompletedTaskCount();
    }

    /**
     * Gets the active count.
     *
     * @return the active count
     */
    public long getActiveCount() {
        return mExecutor.getActiveCount();
    }

    /**
     * Gets the task count.
     *
     * @return the task count
     */
    public long getTaskCount() {
        return mExecutor.getTaskCount();
    }

    /**
     * Checks if is pool full used.
     *
     * @return true, if is pool full used
     */
    public boolean isPoolFullUsed() {
        return mExecutor.getActiveCount() == mMaximumPoolSize;
    }

    /**
     * Destory.
     */
    public void destory() {
        try {
            mExecutor.shutdown();
        } catch (Exception e) {
            LOGGER.error("destory executor pool shutdown fail", e);
        }
    }
}

public class ThreadPoolFactory {

    /**
     * The m normal pool.
     */
    static ThreadPoolProxy mNormalPool;

    /**
     * The mOasPool使用
     */
    static ThreadPoolProxy mOasPool;

    /**
     * Gets the uom pool.
     *
     * @return the uom pool
     */
    public static ThreadPoolProxy getOASPool() {
        if (mOasPool == null) {
            synchronized (ThreadPoolProxy.class) {
                if (mOasPool == null) {
                    mOasPool = new ThreadPoolProxy(50, 400, 300);
                }
            }
        }
        return mOasPool;
    }

    /**
     * Gets the normal pool.
     *
     * @return the normal pool
     */
    public static ThreadPoolProxy getNormalPool() {
        if (mNormalPool == null) {
            synchronized (ThreadPoolProxy.class) {
                if (mNormalPool == null) {
                    mNormalPool = new ThreadPoolProxy(20, 50, 300);
                }
            }
        }
        return mNormalPool;
    }

}