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);
        }
    }
}