package com.csw.shuanfa.utils;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class ThreadPoolUtil {

    /**
     * 【線程池】
     * 使用線程池的10個坑_threadpool nullpointer-CSDN博客  https://blog.csdn.net/weiwenhou/article/details/126358283
     *
     * //建議在方法里面調(diào)用getExecutorServiceCPU方法
     *  ExecutorService threadPool = ThreadPoolUtil.getExecutorServiceCPU();
     *   List<CompletableFuture> completableFutureList = new ArrayList<>();
     *
     *         try {
     *             CompletableFuture<Void> step1 = CompletableFuture.runAsync(() -> {
     *             }, threadPool);
     * completableFutureList.add(future1);
     *
     *             //批量阻塞完成
     *             // CompletableFuture.allOf(futureList.toArray(futureList.toArray(new CompletableFuture[0]))).get(1, TimeUnit.SECONDS);
     *             //CompletableFuture.allOf(future1, future2, future3, future4, future5, future6, future7).get(1, TimeUnit.SECONDS);
     *
     *         } catch (Exception e) {
     *             System.out.println(ThreadPoolUtil.getThreadPoolName());
     *             threadPool.shutdownNow();
     *             throw new RuntimeException(e);
     *         } finally {
     *             threadPool.shutdown();
     *         }
     */


    /**
     * 在方法里面調(diào)用推薦
     * AbortPolicy-拒絕并拋出異常
     */
    public static ExecutorService getExecutorServiceCPU() {
        return getExecutorServiceCPU(false, 0, new ThreadPoolExecutor.AbortPolicy());
    }


    /**
     * @param type true是偏向IO處理連接
     */
    public static ExecutorService getExecutorServiceCPU(boolean type) {
        return getExecutorServiceCPU(type, 0, new ThreadPoolExecutor.AbortPolicy());
    }


    /**
     * @param queneSize 隊(duì)列大小
     */
    public static ExecutorService getExecutorServiceCPU(int queneSize) {
        return getExecutorServiceCPU(false, queneSize, new ThreadPoolExecutor.AbortPolicy());
    }

    /**
     * @param queneSize 隊(duì)列大小
     *                  <p>
     *                  拒絕策略
     *                  AbortPolicy-拒絕并拋出異常
     *                  CallerRunsPolicy-回調(diào)等待不拋出異常
     *                  DiscardPolicy-丟棄新任務(wù)不拋棄異常
     *                  DiscardOldestPolicy-丟棄老任務(wù)不拋棄異常
     *                  <p>
     *                  有隊(duì)列長度才指定決絕策略
     */
    public static ExecutorService getExecutorServiceCPU(int queneSize, RejectedExecutionHandler handler) {
        return getExecutorServiceCPU(false, queneSize, handler);
    }


    /**
     * @param type      true是偏向IO處理連接
     * @param queneSize 隊(duì)列大小
     */
    public static ExecutorService getExecutorServiceCPU(boolean type, int queneSize) {
        return getExecutorServiceCPU(type, queneSize, new ThreadPoolExecutor.AbortPolicy());
    }


    /**
     * @param type      true是偏向IO處理連接
     * @param queneSize 隊(duì)列大小
     *                  <p>
     *                  拒絕策略
     *                  AbortPolicy-拒絕并拋出異常
     *                  CallerRunsPolicy-回調(diào)等待不拋出異常
     *                  DiscardPolicy-丟棄新任務(wù)不拋棄異常
     *                  DiscardOldestPolicy-丟棄老任務(wù)不拋棄異常
     *                  <p>
     *                  有隊(duì)列長度才指定決絕策略
     *
     *                  在一個數(shù)據(jù)處理應(yīng)用中何之，線程池的核心線程數(shù)為 5夫晌，最大線程數(shù)為 10败砂，任務(wù)隊(duì)列大小為 20掷豺。當(dāng)已經(jīng)有 5 個任務(wù)在核心線程中執(zhí)行，20 個任務(wù)在任務(wù)隊(duì)列中等待赎瑰，并且又有新任務(wù)提交時王悍，就會創(chuàng)建新的非核心線程（最多到 10 個線程）來處理這些新任務(wù)破镰。
     *                  當(dāng)隊(duì)列滿了才會用最大線程數(shù)
     */
    public static ExecutorService getExecutorServiceCPU(boolean type, int queneSize, RejectedExecutionHandler handler) {
        int cpuCounts = Runtime.getRuntime().availableProcessors();
        if (cpuCounts <= 8) {
            cpuCounts = 8;
        }
        if (queneSize == 0) {
            queneSize = Integer.MAX_VALUE;
        }
        int poolsize = 0;
        if (type == true) {//偏向IO處理連接
            poolsize = cpuCounts * 2 - 1;
        } else {//cpu型任務(wù)任務(wù)運(yùn)行時間快餐曼，像單線程處理
            poolsize = cpuCounts - 1;
        }

        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat(getThreadPoolNameMethod() + "-%d").build();
        ExecutorService threadPool = new ThreadPoolExecutor(poolsize, poolsize * 2, 60L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(queneSize), namedThreadFactory, handler);
        return threadPool;
    }

    /**
     * 獲取線程池名稱
     *
     * @return
     */
    public static String getThreadPoolNameMethod() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        int j = 0;
        //設(shè)置沒有出現(xiàn)過
        boolean flag = false;
        for (int i = 0; i < stackTrace.length; i++) {
            StackTraceElement element = stackTrace[i];
            //stackTrace[1]是當(dāng)前方法
            if (element.getFileName().equals(stackTrace[1].getFileName())) {
                flag = true;
            } else {
                if (flag == true) {//一旦不相等，并且之前出現(xiàn)過flag=true鲜漩，就是調(diào)用出
                    j = i;
                    break;
                }
            }
        }
        StackTraceElement element = Thread.currentThread().getStackTrace()[j];
        String threadPoolName = element.getMethodName() + "_" + element.getFileName();
        return threadPoolName;
    }
}