自定义线程池

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
import java.util.concurrent.TimeUnit;


/**
 * 自定义线程池
 * @author Tang
 * @date 2020-12-25 18:46:21
 */
public class ThreadPoolUtil {
    private static final ILogger LOGGER = LoggerFactory.getLogger(ThreadPoolUtil.class);
    /**
     * 默认最大并发数<br>
     */
    private static final int DEFAULT_MAX_CONCURRENT = Runtime.getRuntime().availableProcessors();

    /**
     * 线程工厂名称
     */
    private static final ThreadFactory FACTORY = Executors.defaultThreadFactory();

    /**
     * 默认队列大小
     */
    private static final int DEFAULT_SIZE = 100;

    /**
     * 默认线程存活时间
     */
    private static final long DEFAULT_KEEP_ALIVE = 60L;

    /**
     * Executor
     */
    private static ExecutorService executor;

    /**
     * 执行队列
     */
    private static BlockingQueue<Runnable> executeQueue = new ArrayBlockingQueue<Runnable>(DEFAULT_SIZE);

    /**
     * 拒绝策略，丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
     */
    private static DiscardOldestPolicy discardOldestPolicy = new ThreadPoolExecutor.DiscardOldestPolicy();

    static {
        // 创建 Executor
        // 此处默认最大值改为处理器数量的 2 倍+2,2N+2
        try {
            executor = new ThreadPoolExecutor(
                    DEFAULT_MAX_CONCURRENT,
                    (DEFAULT_MAX_CONCURRENT * 2)+2, 
                    DEFAULT_KEEP_ALIVE,
                    TimeUnit.SECONDS, 
                    executeQueue, 
                    FACTORY,
                    discardOldestPolicy);

            // 关闭事件的挂钩
            Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
                public void run() {
                    LOGGER.info("ThreadPoolUtil shutting down.");
                    executor.shutdown();
                    try {
                        // 等待1秒执行关闭
                        if (!executor.awaitTermination(1, TimeUnit.SECONDS)) {
                            LOGGER.error("ThreadPoolUtil shutdown immediately due to wait timeout.");
                            executor.shutdownNow();
                        }
                    } catch (InterruptedException e) {
                        LOGGER.error("ThreadPoolUtil shutdown interrupted.");
                        executor.shutdownNow();
                    }
                    LOGGER.info("ThreadPoolUtil shutdown complete.");
                }
            }));
            
        } catch (Exception e) {
            LOGGER.error("ThreadPoolUtil init error.", e);
            throw new ExceptionInInitializerError(e);
        }
    }

    /**
     * 构造函数私有，此类型无法实例化
     */
    private ThreadPoolUtil() {
    }

    /**
     * 执行任务，不管是否成功<br>
     * 其实也就是包装以后的 {@link Executer} 方法
     * 
     * @param task
     * @return
     */
    public static boolean executeTask(Runnable task) {

        try {
            executor.execute(task);
        } catch (RejectedExecutionException e) {
            LOGGER.error("Task executing was rejected.", e);
            return false;
        }
        return true;
    }

    /**
     * 提交任务，并可以在稍后获取其执行情况<br>
     * 当提交失败时，会抛出 {@link }
     * 
     * @param task
     * @return
     */
    public static <T> Future<T> submitTask(Callable<T> task) {

        try {
            return executor.submit(task);
        } catch (RejectedExecutionException e) {
            LOGGER.error("Task executing was rejected.", e);
            throw new UnsupportedOperationException("Unable to submit the task, rejected.", e);
        }
    }
}