6、并发编程基础-深入理解Excecutors执行器和线程池

1、认识Excecutors执行器

Executor框架是指java 1.5中引入的一系列并发核心包，在在java.util.concurrent包中。其中并发包，Executor，Executors，ExecutorService，CompletionService，Future，Callable等，他们的关系为

这里写图片描述

其中在并发包中有一个比较重要的类：Executors，他扮演线程工厂的角色，我们通过Executors可以创建特定功能的线程池。Exectuors有一个方法exectute()来自父类，是专门来执行委托任务的，只需要将线程任务提交给它就能帮助我们执行线程任务。在Executor框架中，使用执行器(Exectuor)来管理Thread对象，从而简化了并发编程开发。

Executors创建线程池的常用方法如下：

newFixedThreadPool()方法，该方法返回一个固定数量的线程池，该方法的线程数量始终不变，当有一个任务提交时，若线程池中空闲，即立刻执行，若线程池用完，则会被暂缓存在一个任务队列中等待有空闲的线程池去执行。
newSingleThreadExecutor()方法，创建一个线程的线程池，若空闲则执行，若没有空闲线程则暂缓存在任务队列中。
newCachedThreadPool()方法，返回一个可根据实际情况调整线程个数的线程池。不限制最大线程数量，若有空闲的线程则执行任务，若无任务则不创建线程，并且每一个空闲线程会在60秒后自动回收。
newScheduledTheadPool()方法，该方法返回一个SchedeExcutorService对象，但该线程是可以指定线程的数量。

备注：其实Executors本身并不能够创建线程池，它所有的方法之所有能够创建线程池，是因为它底层调用了ThreadPoolExecutor这个线程类。ThreadPoolExecutor才是真正创建线程池的。

通过对 ThreadPoolExecutor 这类的构造方法传递不同的参数，可以实现不同的线程池效果，可见这个类是多么的强大。根据阿里巴巴开发规范，一般也是建议使用ThreadPoolExecutor去创建线程，这样会更加安全，里面可以根据自己的需求使用不同的并行队列去控制线程池。

2、认识 ThreadPoolExecutor 线程池类

ThreadPoolExecutor 构造函数的内部源码如下：

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {

if (corePoolSize < 0 ||maximumPoolSize <= 0 ||maximumPoolSize < corePoolSize ||keepAliveTime < 0)
    throw new IllegalArgumentException();

if (workQueue == null || threadFactory == null || handler == null)
    throw new NullPointerException();
    this.acc = System.getSecurityManager() == null ?null :AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

构造方法各个参数说明如下：

corePoolSize：实际初始化线程数
maximumPoolSize：最大线程数
keepAliveTime：线程所允许在线程池的空闲时间
unit：时间单位，是定义keepAliveTime 的时间单位
workQueue：任务队列，用来缓存需要执行的任务的
handler：线程池对拒绝任务的处理策略

重点，重点，重点，重要的时候说三次。ThreadPoolExecutor构造方法对于使用什么队列是什么非常关键，不懂这个你就没办法正确安全的使用线程池，别怪我没提醒你：

在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize,则优先创建线程corePoolSize个线程数，任务直接执行，任务不会被放到workQueue；若大于corePoolSize，则会将任务缓存入workQueue任务队列；若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，直到达到maximumPoolSize的最大值；若线程数大于 maximumPoolSize 则执行拒绝策略（决绝策略不建议用jdk提供的，很不友好，建议自定义），此时就会有任务丢失的情况，但也有效的减少过多占用系统内存资源。

备注：自定义决绝策略需要实现 RejectedExecutionHandler 。一般拒绝策略执行会使用日记把数据记录记录下来，或者使用http请求，或者其他程序告知出去。一般不要把拒绝策略里面的数据保存到缓存中去，因为这样没有意义，毕竟是因为系统资源不足了才会使用拒绝策略，如果系统资源充足没必要使用拒绝策略，可以考虑有界队列扩容就好。

在使用无界队列时，LinkedBlockingQueue。与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新任务到来，系统的线程数小于corePoolSize时，则新建线程直接执行任务，任务不会被放到workQueue；当达到corePoolSize后，就不会继续增加，maximumPoolSize对于无界队列是无效的，线程池最大只能是corePoolSize；若后续仍有新的任务加入，而且没有空闲的线程资源，则任务将会加入进workQueue队列进行等待；若任务创建和处理的速度差异很大，生产者快速的生产，消费者没办法快速消费，workQueue队列会保持快速增长，直到耗尽系统内存，造成机器宕机。

workQueue参数很重要，其实2种类型队列都各有优点和缺点，在项目中看自己的实际情况使用即可。

下面来一段测试代码：

public class UseThreadPoolExecutor1 {


    public static void main(String[] args) {
        /**
         * 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
         * 若大于corePoolSize，则会将任务加入队列，
         * 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
         * 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
         * 
         */ 
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,                                     //coreSize
                2,                                     //MaxSize
                60,                                    //60
                TimeUnit.SECONDS,                      //设定时间单位
                new ArrayBlockingQueue<Runnable>(3)    //指定一种队列 （有界队列）
                //new LinkedBlockingQueue<Runnable>()
                , new MyRejected()
                //, new DiscardOldestPolicy()
                );

        MyTask mt1 = new MyTask(1, "任务1");
        MyTask mt2 = new MyTask(2, "任务2");
        MyTask mt3 = new MyTask(3, "任务3");
        MyTask mt4 = new MyTask(4, "任务4");
        MyTask mt5 = new MyTask(5, "任务5");
        MyTask mt6 = new MyTask(6, "任务6");

        pool.execute(mt1);
        pool.execute(mt2);
        pool.execute(mt3);
        pool.execute(mt4);
        pool.execute(mt5);
        pool.execute(mt6);

        pool.shutdown();

    }
}

JDK提供的拒绝策略（因为不太友好不推荐使用，尽量推荐自定义策略）：

AbortPolicy：直接抛出异常组织系统正常工作
CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。
DiscardOldestPolicy：丢弃最老的一个请求，尝试再次提交当前任务。
DiscardPolicy：丢弃无法处理的任务，不给予任何处理。

如果要自定义拒绝策略可以现实RejectedExecutionHandler 接口。

如下：

public class MyRejected implements RejectedExecutionHandler{
    public MyRejected(){
    }
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("自定义处理..");
        System.out.println("当前被拒绝任务为：" + r.toString());
    }
}