线程池策略

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

}