在第一篇文章中，我们发现ThreadPoolExecutor 提供四个构造器供我们创建一个线程池。关于是否使用ThreadPoolExecutor 来创建线程池，下面有两种说法：

1.虽然ThreadPoolExecutor 有四个不同的构造器，但是考虑到其复杂性，Java并发API提供了Executors类来构建执行器和相关对象。尽管我们可以直接通过其构造函数来生成ThreadPoolExecutor ，使用Executors类是更加推荐的方式

2.阿里的 Java开发手册中这样说道：【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，

这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

那么我的理解就是，如果 追求ThreadPoolExecutor 的简单实现那么就是用Executors去创建线程池，如果考虑到资源的问题，那就使用ThreadPoolExecutor的方式去创建。具体的我也只能在后面的实际工作中去琢磨了，现在多多学习吧，趁着毕业设计回校这段时间多多补充一些Java底层的知识。

下面来研究一下Executors这个执行器类:

可以发现这些方法返回实现ExecutorService接口的ThreadPoolExecutor类的对象

其创建线程池的方法：

1.newFixedThreadPool

2.newSingleThreadExecutor

3.newCachedThreadPool

第一个方法创建了一个固定大小的线程池，如果提交的任务多余空闲线程数目，那么多余的任务则放入到队列之中。

第二个方法是以单一的线程的线程池：由一个线程执行提交的任务，一个接着一个。

第三个方法构建的线程池，对于每一个任务，如果有空闲线程则直接使用，没有就创建一个新的线程。

使用第一方法来看一下效果：

public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i=0;i<12;i++){
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("开始处理线程！！！");
                        Thread.sleep(1000);
                        System.out.println("Thread:"+this.toString());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

        }
        executorService.shutdown();
    }

可见当线程满10个后，第11和地12个任务就放在队列之中，当其他任务执行完后，开始执行队列中的线程。

把newFixedThreadPool改成newCachedThreadPool后可见来多少任务就创建多少线程去执行任务

再改成newSingleThreadExecutor后可见线程使依次执行任务，执行完一个任务之后再去执行另一个任务

这里补充另一个创建线程池的理由：减少并发线程的数目。创建大量的线程会大大降低性能甚至使虚拟机崩溃，应该使用一个线程数“固定的”线程池来限制并发线程的数目。

使用Executors的方法很简单的去创建了线程池，但是确实好像简单了很多，不要去配置那么多的参数。但是也确实好像会造成资源浪费，并且该类方法返回的实现了ExecutorService接口的ThreadPoolExecutor，并没有传入RejectedExecutionHandler （拒绝策略）这个参数 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。看网上的文章觉得：这点可能会非常重要吧。。

那就研究一下ThreadPoolExecutor的拒绝策略吧：

四种拒绝策略：CallerRunsPolicy,AbortPolicy,DiscardPolicy,DiscardOldestPolicy

第一种：

ThreadPoolExecutor executor = new ThreadPoolExecutor(2,
            4, 200, TimeUnit.MILLISECONDS,
            new ArrayBlockingQueue<Runnable>(2),new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 11; i++) {
        int num = i;
        executor.execute(new Runnable() {
        @Override
        public void run() {
        System.out.println("正在執行task" + Thread.currentThread().getName());

        System.out.println("task:" +  Thread.currentThread().getName()+ "執行結束");
        }
        });
        }
        executor.shutdown();

可见：CallerRunsPolicy方法是在任务被拒绝添加后，会调用当前线程池的所在的线程去执行被拒绝的任务。但是会阻塞主线程

第二种：AbortPolicy 源码如下，可以发现其直接抛出异常，不在继续执行后续的任务

public static class AbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public AbortPolicy() { }

        /**
         * Always throws RejectedExecutionException.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

执行效果

第三种：DiscardPolicy 源码中方法体是空的，也就是不做处理，不创建新的线程，继续处理前面的任务

/**
     * A handler for rejected tasks that silently discards the
     * rejected task.
     */
    public static class DiscardPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardPolicy}.
         */
        public DiscardPolicy() { }

        /**
         * Does nothing, which has the effect of discarding task r.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

测试代码：

ThreadPoolExecutor executor = new ThreadPoolExecutor(2,
            4, 200, TimeUnit.MILLISECONDS,
            new ArrayBlockingQueue<Runnable>(2),new ThreadPoolExecutor.DiscardPolicy());
        for (int i = 0; i < 11; i++) {
            System.out.println("Thread"+i+"create");
        executor.execute(new Runnable() {
        @Override
        public void run() {
        System.out.println("正在執行task" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("task:" +  Thread.currentThread().getName()+ "執行結束");
        }
        });
        }
        executor.shutdown();

测试结果：

可见循环进入后，并没有去创建线程，而是直接执行以创建的任务

第四种：DiscardOldestPolicy 从名字上看应该是放弃最早的线程去执行最新

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardOldestPolicy} for the given executor.
         */
        public DiscardOldestPolicy() { }

        /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

测试代码：

ThreadPoolExecutor executor = new ThreadPoolExecutor(2,
            4, 200, TimeUnit.MILLISECONDS,
            new ArrayBlockingQueue<Runnable>(2),new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 0; i < 11; i++) {
        int index = i ;
        System.out.println("Thread"+i+"create");
        System.out.println(((ThreadPoolExecutor)executor).getQueue().size());
        executor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("正在執行task："+index + ":"+ Thread.currentThread().getName());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("task:"+index + ":"+  Thread.currentThread().getName()+ "執行結束");
            }
        });
    }
        executor.shutdown();

执行效果：

可见看到在达到最大线程的时候，4和5线程放入到队列当中，但是最后执行的时候是任务9和10。也就是说discardoldestpolicy

策略会将最前面的没有执行的线程替换掉，已经执行的就让它执行完

再说一下Executors中几个方法的缺点吧

说明：Executors 各个方法的弊端： 1）newFixedThreadPool 和 newSingleThreadExecutor: 主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至 OOM（java.lang.OutOfMemoryError：堆内存溢出）。 2）newCachedThreadPool

主要问题是线程数最大数是 Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至 OOM

看着源码，看着书，以及网上查阅别人的博客，就自己感觉线程池创建似乎使用Executors会很方便，不需要去了解ThreadPoolExecutor太多东西，就可以创建线程池，很方便。但是对于有实际硬性要求的项目，貌似自己去实现ThreadPoolExecutor，根据不同的需求去设置不同参数更加合适一些。所以我觉得还是多多了解一下ThreadPoolExecutor这个类比较好一些，因为Executors也是返回该类的实例。