Java并发——Executor框架ThreadPoolExecutor详解

ThreadPoolExecutor是Executor接口的一个重要的实现类，是线程池的具体实现，用来执行被提交的任务。

一、ThreadPoolExecutor的创建：

• 直接创建ThreadPoolExecutor的实例对象，这样需要自己配置ThreadPoolExecutor中的每一个参数：

ThreadPoolExecutor tpe = new ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit, BlockingQueue<Runnable> workQueue);

每个参数的具体设置参见： 点击打开链接

• ThreadPoolExecutor通过Executors工具类来创建ThreadPoolExecutor的子类FixedThreadPool、SingleThreadExecutor、CachedThreadPool，这些子类继承ThreadPoolExecutor，并且其中的一些参数已经被配置好。

//FixedThreadPoll
ExecutorService ftp = Executors.newFixedThreadPool(int threadNums);
ExecutorService ftp = Executors.newFixedThreadPool(int threadNums, ThreadFactory threadFactory);
//SingleThreadExecutor
ExecutorService ste = Executors.newSingleThreadExecutor();
ExecutorService ste = Executors.newSingleThradPool(ThreadFactory threadFactory);
//CachedThreadPool
ExecutorService ctp = Executors.newCachedThreadPool();
ExecutorService ctp = Executors.newCachedThreadPool(ThreadFactory threadFactory);

关于ThreadFactory接口，参见：点击打开链接

二、ThreadPoolExecutor的子类FixedThreadPool、SingleThreadExecutor、CachedThreadPool详解

FixedThreadPool、SingleThreadExecutor、CachedThreadPool都是通过Executors工厂类中的工厂方法创建的，因此我们对这几个方法进行分析。

1、FixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }

应用场景：FixedThreadPool是线程数量固定的线程池，适用于为了满足资源管理的需求，而需要适当限制当前线程数量的情景，适用于负载比较重的服务器。

可以看出它的实现就是把线程池最大线程数量maxmumPoolSize和核心线程池的数量corePoolSize设置为相等，并且使用LinkedBlockingQueue作为阻塞队列，那么首先可以知道线程池的线程数量最多就是nThread，只会在核心线程池阶段创建，此外，因为LinkedBlockingQueue是无限的双向队列，因此当任务不能立刻执行时，都会添加到阻塞队列中，因此可以得到FixedThreadPool的工作流程大致如下：

• 当前核心线程池总线程数量小于corePoolSize，那么创建线程并执行任务；
• 如果当前线程数量等于corePoolSize，那么把 任务添加到阻塞队列中；
• 如果线程池中的线程执行完任务，那么获取阻塞队列中的任务并执行；

*注意：因为阻塞队列是无限的双向队列，因此如果没有调用shutDownNow（）或者shutDown（）方法，线程池是不会拒绝任务的，如果线程池中的线程一直被占有，FixedThreadPool是不会拒绝任务的。

因为使用的是LinkedBlockingQueue，因此maximumPoolSize，keepAliveTime都是无效的，因为阻塞队列是无限的，因此线程数量肯定小于等于corePoolSize，因此keepAliveTime是无效的；

2、SingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }

应用场景：SingleThreadExecutor是只有一个线程的线程池，常用于需要让线程顺序执行，并且在任意时间，只能有一个任务被执行，而不能有多个线程同时执行的场景。

因为阻塞队列使用的是LinkedBlockingQueue，因此和FixedThreadPool一样，maximumPoolSize，keepAliveTime都是无效的。corePoolSize为1，因此最多只能创建一个线程，SingleThreadPool的工作流程大概如下：

• 当前核心线程池总线程数量小于corePoolSize（1），那么创建线程并执行任务；
• 如果当前线程数量等于corePoolSize，那么把 任务添加到阻塞队列中；
• 如果线程池中的线程执行完任务，那么获取阻塞队列中的任务并执行；

3、CachedThreadPool

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

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

应用场景：CachedThreadPool适用于执行很多短期异步任务的小程序，或者是负载较轻的服务器。

CachedThreadPool使用SynchronizedQueue作为阻塞队列，SynchronizedQueue是不存储元素的阻塞队列，实现“一对一的交付”，也就是说，每次向队列中put一个任务必须等有线程来take这个任务，否则就会一直阻塞该任务，如果一个线程要take一个任务就要一直阻塞知道有任务被put进阻塞队列。

因为CachedThreadPool的maximumPoolSize为Integer.MUX_VALUE，因此CachedThreadPool是无界的线程池，也就是说可以一直不断的创建线程。corePoolSize为0 ，因此在CachedThreadPool中直接通过阻塞队列来进行任务的提交。

CachedThreadPool的工作流程大概如下：

• 首先执行SynchronizedQueue.offer(  )把任务提交给阻塞队列，如果这时候正好在线程池中有空闲的线程执行SynchronizedQueue.poll( )，那么offer操作和poll操作配对，线程执行任务；
• 如果执行SynchronizedQueue.offer(  )把任务提交给阻塞队列时maximumPoolSize=0.或者没有空闲线程来执行SynchronizedQueue.poll( )，那么步骤1失败，那么创建一个新线程来执行任务；
• 如果当前线程执行完任务则循环从阻塞队列中获取任务，如果当前队列中没有提交（offer）任务，那么线程等待keepAliveTime时间，在CacheThreadPool中为60秒，在keepAliveTime时间内如果有任务提交则获取并执行任务，如果没有则销毁线程，因此最后如果一直没有任务提交了，线程池中的线程数量最终为0。

*注意：因为maximumPoolSize=Integer.MAX_VALUE，因此可以不断的创建新线程，这样可能会CPU和内存资源耗尽。