線程池策略

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
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;

/**
 * Created by chao0 on 2016/5/26.
 *
 * corePoolSize ： 線程池維護線程的最少數量，哪怕是空閒的。
 maximumPoolSize ：線程池維護線程的最大數量。
 keepAliveTime ： 線程池維護線程所允許的空閒時間。
 unit ： 線程池維護線程所允許的空閒時間的單位。
 workQueue ： 線程池所使用的緩衝隊列，改緩衝隊列的長度決定了能夠緩衝的最大數量。
 拒絕任務：拒絕任務是指當線程池裏面的線程數量達到 maximumPoolSize 且 workQueue 隊列已滿的情況下被嘗試添加進來的任務。
 handler ： 線程池對拒絕任務的處理策略。在 ThreadPoolExecutor 裏面定義了 4 種 handler 策略，分別是
 1. CallerRunsPolicy ：這個策略重試添加當前的任務，他會自動重複調用 execute() 方法，直到成功。
 2. AbortPolicy ：對拒絕任務拋棄處理，並且拋出異常。
 3. DiscardPolicy ：對拒絕任務直接無聲拋棄，沒有異常信息。
 4. DiscardOldestPolicy ：對拒絕任務不拋棄，而是拋棄隊列裏面等待最久的一個線程，然後把拒絕任務加到隊列。

 一個任務通過 execute(Runnable) 方法被添加到線程池，任務就是一個 Runnable 類型的對象，任務的執行方法就是 Runnable 類型對象的 run() 方法。
 當一個任務通過 execute(Runnable) 方法欲添加到線程池時，線程池採用的策略如下：
 1. 如果此時線程池中的數量小於 corePoolSize ，即使線程池中的線程都處於空閒狀態，也要創建新的線程來處理被添加的任務。
 2. 如果此時線程池中的數量等於 corePoolSize ，但是緩衝隊列 workQueue 未滿，那麼任務被放入緩衝隊列。
 3. 如果此時線程池中的數量大於 corePoolSize ，緩衝隊列 workQueue 滿，並且線程池中的數量小於maximumPoolSize ，建新的線程來處理被添加的任務。
 4. 如果此時線程池中的數量大於 corePoolSize ，緩衝隊列 workQueue 滿，並且線程池中的數量等於maximumPoolSize ，那麼通過 handler 所指定的策略來處理此任務。
 處理任務的優先級爲：
 核心線程 corePoolSize 、任務隊列 workQueue 、最大線程 maximumPoolSize ，如果三者都滿了，使用 handler處理被拒絕的任務。當線程池中的線程數量大於 corePoolSize 時，如果某線程空閒時間超過 keepAliveTime ，線程將被終止。這樣，線程池可以動態的調整池中的線程數。
 理解了上面關於 ThreadPoolExecutord 的介紹，應該就基本能瞭解它的一些使用，不過在 ThreadPoolExocutor裏面有個關鍵的 Worker 類，所有的線程都要經過 Worker 的包裝。這樣才能夠做到線程可以複用而無需重新創建線程。
 同時 Executors 類裏面有 newFixedThreadPool(),newCachedThreadPool() 等幾個方法，實際上也是間接調用了ThreadPoolExocutor ，不過是傳的不同的構造參數。

 上面的這段話轉載了http://blog.csdn.net/psiitoy/article/details/38587293
 */
public class ThreadPoolPorxy {
    //線程池接口
    private ThreadPoolExecutor executor;
    //線程池核心線程個數
    private int corePoolSize;
    //線程池的最大線程個數
    private int maximumPoolSize;
    //線程池的線程保持時間
    private long keepAliveTime;
    private static ThreadPoolPorxy threadPoolPorxy;
    private ThreadPoolPorxy(int corePoolSize,int maximumPoolSize, long keepAliveTime){
        this.corePoolSize=corePoolSize;
        this.maximumPoolSize=maximumPoolSize;
        this.keepAliveTime=keepAliveTime;
        initThreadPoolPorxy();
    }
    public void initThreadPoolPorxy(){
        //線程池的任務隊列
        BlockingQueue<Runnable> workQueue=new LinkedBlockingQueue<>();
        //生產線程池的工廠
        ThreadFactory threadFactory= Executors.defaultThreadFactory();
        //線程池的拒絕策略
        RejectedExecutionHandler handler=new ThreadPoolExecutor.AbortPolicy();
        //TimeUnit.SECONDS 時間單位
        executor=new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime, TimeUnit.SECONDS, workQueue,threadFactory,handler);
    }
    public static ThreadPoolPorxy getThreadPoolPorxy(int corePoolSize,int maximumPoolSize, long keepAliveTime){
       if (threadPoolPorxy==null){
           synchronized (ThreadPoolPorxy.class){
               if (threadPoolPorxy==null){
                 threadPoolPorxy=new ThreadPoolPorxy(corePoolSize,maximumPoolSize,keepAliveTime);
               }
           }
       }
        return threadPoolPorxy;
    }
    public void execute(Runnable runnable){
        executor.execute(runnable);
    }
    public void remove(Runnable runnable){
        executor.remove(runnable);
    }

}