ThreadPoolExecutor(int corePoolSize,?
int maximumPoolSize,?
long keepAliveTime,?
TimeUnit unit,?
BlockingQueue<Runnable> workQueue)

ThreadPoolExecutor(int corePoolSize,?
int maximumPoolSize,?
long keepAliveTime,?
TimeUnit unit,?
BlockingQueue<Runnable> workQueue,?
RejectedExecutionHandler handler)

ThreadPoolExecutor(int corePoolSize,?
int maximumPoolSize,
long keepAliveTime,
BlockingQueue<Runnable> workQueue,?
ThreadFactory threadFactory)

ThreadPoolExecutor(int corePoolSize,?
int maximumPoolSize,?
long keepAliveTime,?
TimeUnit unit,
BlockingQueue<Runnable> workQueue,?
RejectedExecutionHandler handler)

public class ThreadPool {
? ? /**
? ? ?* 線程池的基本大小
? ? ?*/
? ? static int corePoolSize = 10;
? ? /**
? ? ?* 線程池最大數(shù)量
? ? ?*/
? ? static int maximumPoolSizeSize = 100;
? ? /**
? ? ?* 線程活動保持時間
? ? ?*/
? ? static long keepAliveTime = 1;
? ? /**
? ? ?* 任務(wù)隊(duì)列
? ? ?*/
? ? static ArrayBlockingQueue workQueue = new ArrayBlockingQueue(10);
? ? public static void main(String[] args) {
? ? ? ? ThreadPoolExecutor executor = new ThreadPoolExecutor(
? ? ? ? ? ? ? ? corePoolSize,
? ? ? ? ? ? ? ? maximumPoolSizeSize,
? ? ? ? ? ? ? ? keepAliveTime,
? ? ? ? ? ? ? ? TimeUnit.SECONDS,
? ? ? ? ? ? ? ? workQueue,
? ? ? ? ? ? ? ? new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build());
? ? ? ? //提交一個任務(wù)
? ? ? ? executor.execute(() -> System.out.println("ok"));
? ? }
}

public void execute(Runnable command) {
? ? ? ? if (command == null)
? ? ? ? ? ? throw new NullPointerException();
? ? ? ? /*
? ? ? ? ?* Proceed in 3 steps:
? ? ? ? ?*
? ? ? ? ?* 1. If fewer than corePoolSize threads are running, try to
? ? ? ? ?* start a new thread with the given command as its first
? ? ? ? ?* task. ?The call to addWorker atomically checks runState and
? ? ? ? ?* workerCount, and so prevents false alarms that would add
? ? ? ? ?* threads when it shouldn't, by returning false.
? ? ? ? ?*
? ? ? ? ?* 2. If a task can be successfully queued, then we still need
? ? ? ? ?* to double-check whether we should have added a thread
? ? ? ? ?* (because existing ones died since last checking) or that
? ? ? ? ?* the pool shut down since entry into this method. So we
? ? ? ? ?* recheck state and if necessary roll back the enqueuing if
? ? ? ? ?* stopped, or start a new thread if there are none.
? ? ? ? ?*
? ? ? ? ?* 3. If we cannot queue task, then we try to add a new
? ? ? ? ?* thread. ?If it fails, we know we are shut down or saturated
? ? ? ? ?* and so reject the task.
? ? ? ? ?*/
? ? ? ? int c = ctl.get();
? ? ? ? if (workerCountOf(c) < corePoolSize) {
? ? ? ? ? ? if (addWorker(command, true))
? ? ? ? ? ? ? ? return;
? ? ? ? ? ? c = ctl.get();
? ? ? ? }
? ? ? ? if (isRunning(c) && workQueue.offer(command)) {
? ? ? ? ? ? int recheck = ctl.get();
? ? ? ? ? ? if (! isRunning(recheck) && remove(command))
? ? ? ? ? ? ? ? reject(command);
? ? ? ? ? ? else if (workerCountOf(recheck) == 0)
? ? ? ? ? ? ? ? addWorker(null, false);
? ? ? ? }
? ? ? ? else if (!addWorker(command, false))
? ? ? ? ? ? reject(command);
? ? }

public class ThreadPoolUtils {
    public static ThreadPoolExecutor pool=null;
    // 無響應(yīng)執(zhí)行
    public static void execute(Runnable runnable){
        getThreadPool().execute(runnable);
    }
    // 有響應(yīng)執(zhí)行
    public static<T> Future<T> submit(Callable<T> callable){
        return getThreadPool().submit(callable);
    }
    // 創(chuàng)造線程池
    private static synchronized ThreadPoolExecutor getThreadPool(){
        if(pool==null){
            // 獲取處理器數(shù)量
            int cpuNum = Runtime.getRuntime().availableProcessors();
            // 根據(jù)cpu數(shù)量,計(jì)算出合理的線程并發(fā)數(shù)
            // 最佳線程數(shù)目 = （（線程等待時間+線程CPU時間）/線程CPU時間 ）* CPU數(shù)目
            int maximumPoolSize = cpuNum * 2 + 1;
            // 七個參數(shù)
            // 1. 核心線程數(shù)
            // 2. 最大線程數(shù)
            // 3. 空閑線程最大存活時間
            // 4. 時間單位
            // 5. 阻塞隊(duì)列
            // 6. 創(chuàng)建線程工廠
            // 7. 拒絕策略
            pool=new ThreadPoolExecutor(maximumPoolSize-1,
            maximumPoolSize,
            5,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(50),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());
        }
        return pool;
    }
}