并发编程之Executors（五）

前言：

有了之前的ThreadPoolExecutor基础，本篇分析Executors就非常容易了。本文只讨论Executors类的几个创建线程池的方法，并对Fix和Single区别做了着重分析。

1、Executors类：

该类用于生成线程池，可以生成单线程线程池、固定线程数线程池等等。本科的好朋友让我分析下Fix和Single的区别，想必他也是忙的没时间，我尽量分析的透彻些。就从Single和Fix线程池开始吧。

newSingleThreadExecutor()和newFixedThreadPool()方法：

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService      //这里用到了装饰器模式，这是与Fix的唯一区别
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
}

两个方法对比一下可以发现，Single线程池在ThreadPoolExecutor基础上又封装了一层FinalizableDelegatedExecutorService类：

static class FinalizableDelegatedExecutorService
        extends DelegatedExecutorService {
        FinalizableDelegatedExecutorService(ExecutorService executor) {
            super(executor);
        }
        protected void finalize() {
            super.shutdown();
        }
    }

FinalizableDelegatedExecutorService类里面多了一个finalize()方法，该方法实际上调用的是线程池的shutdown()方法把线程池状态变为SHUTDOWN（即把任务执行完而不接受新任务）。熟悉JVM的你们应该都清楚，finalize()方法是Object类的方法，在系统GC的时候会而且只会被调用一次。

• 另外，如果你使用的是ExecutorService es = Executors.newXXXThreadPool()；这种方式创建的Fix和Single由于返回的是顶层接口ExecutorService，因而也限定了es能使用的方法只有顶层接口的方法，此时Fix和Single创建的线程除了GC销毁线程没有别的区别。但是如果使用ThreadPoolExecutor es = Executors.newFixThreadPool(1)；（注意Single没办法用ThreadPoolExecutor声明）区别就出现了，Fix可以后期配置线程数目如setCorePoolSize、setMaximumPoolSize等ThreadPoolExecutor中的方法，但是Single只能用ExecutorService顶层接口的方法（DelegateExecutorService只实现了顶层接口的方法）。
  所以Fix和Single有两个区别：

区别一：所以在垃圾回收的时候Single线程池相对Fix线程池多了一步关闭线程池销毁线程的方法。
区别二：Fix单线程的时候后期可以配置/更改线程池，但是Single不可以。

Single和Fix区别代码解释：

向下转型确实不是非常好用的方式，《阿里编程规约》要求自己手动创建线程池除了防止任务队列过长和线程数过多导致的OOM之外，这也应该算是一点吧。

        ThreadPoolExecutor fix = (ThreadPoolExecutor) Executors.newFixedThreadPool(1);
        fix.setCorePoolSize(2);
        ExecutorService single = Executors.newSingleThreadExecutor();
        fix.execute(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                System.out.println(fix.getCorePoolSize());
            }

        });
        single.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }

        });

newCachedThreadPool（）方法：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

这个方法允许最大线程数目可以是无限大，而且保活60秒，有OOM的风险。注意里面使用的队列SynchronousQueue，该队列不会堆积任务，只要有任务来（生产者）就会有线程（消费者）处理。我们后期可以探讨一下其他的线程安全的队列放到这里。

newScheduledThreadPool()方法：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

该方法可以定时执行任务，就不做过多的介绍了。

callable()方法：

public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
}
static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
 }

• 本方法内部使用了适配器模式，把Callable和Runnable两种任务通过适配器连接到了一起。最后该方法返回的实际上是Callable类型的任务。