1 线程池简介

线程池指的是ThreadPoolExecutor，它实现了ExecutorService接口，并封装了一系列的api使得它具有线程池的特性，其中包括工作队列、核心线程数、最大线程数等。

可以通过new ThreadPoolExecutor(...)来创建一个线程池，但并不建议这样创建线程池，ThreadPoolExecutor的构造函数如下：

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

官方并不推荐使用这种方法创建线程池，而是推荐使用Executors的工厂方法来创建线程池，Executors类是官方提供的一个工厂类，里面封装了许多功能不一的线程池，主要包括以下五种线程池

• newFixedThreadPool()

作用：该方法返回一个固定线程数量的线程池，该线程池中的线程数量始终不变，即不会再创建新的线程池，也不会销毁已经创建好的线程，自始至终都是那几个固定的线程在工作，所以该线程池可以控制线程的最大并发数。
例子：假如有一个新任务提交时，如果线程池中有空闲的线程，则立即使用空线程来处理任务，如果没有，则会把这个新任务存放在一个任务队列中，一旦有线程空闲，则按FIFO方式处理任务队列中的任务。

• newCachedThreadPool()

作用：该方法返回一个可以根据实际情况调整线程池中线程数量的线程池。即该线程池中的线程数量不确定，是根据实际情况动态调整的。
例子：假如线程池中的所有线程都正在工作，而此时有新任务提交，那么将会创建新想线程去处理该任务，而此时假如之前有一些线程完成了任务，现在又有新任务提交，那么将不会创建新线程去处理，而是复用空闲的线程去处理新任务。那么此时可能有人会有疑问，如果这样，该线程池的线程岂不是越来越多？其实并不会，因为线程池中的线程都有个“保持活动时间”参数，通过配置它，如果线程池中的空闲线程的空闲时间超过该“保持活动时间”，则立即销毁该线程，而该线程池默认的“保持活动时间”为60s。

• newSingleThreadExecutor()

作用：该方法返回一个只用一个线程的线程池，即每次只执行一个线程任务，多余的任务会保存到一个任务队列中，等待这个线程池空闲，然后再按照FIFO方式顺序执行任务队列中的任务。

• newScheduledThreadPool()

作用：该方法返回一个可以控制线程池内线程定时或周期性执行某任务的线程池。

• newSingleThreadScheduledExecutor()

作用：该方法返回一个可以控制线程池内线程定时或周期性执行某任务的线程池。只不过和上面的区别是，该线程池的大小为1，而上面的可以指定线程池的大小。

这5中线程池的初始化如下所示：

    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
    ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
    ScheduledExecutorService singleThreadScheduledPool = Executors.newSingleThreadScheduledExecutor();

通过工厂类Executors创建的线程池其内部还是通过new ThreadPoolExecutor(...)来实现的，下面是前三种线程池的内部实现：

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

2 ThreadPoolExecutor

ThreadPoolExecutor构造函数如下：

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

下面对该构造函数的相关参数进行解释

corePoolSize：线程池中的核心线程数量
maximumPoolSize：线程池中的最大线程数量
keepAliveTime：这个就是上面所说的“保持活动时间”，上面只是大概说明了一下它的作用，它的作用必须在一个前提下，就是当线程池中的线程数量超过corePoolSize，它表示多余线程存活时间，即：多余的空闲线程在超过keepAliveTime时间内没有任务的话则销毁。而这个主要应用在缓存线程池中。
unit：它是一个枚举类型，表示keepAliveTime的单位，常用的如：TimeUnit.SECONDS(秒)、TimeUnit.MILLISECONDS（毫秒）
workQueue：任务队列，主要用来存储已经提交但未被执行的任务，不同线程池采用的排队策略不一样。
threadFactory：线程工厂，用来创建线程池中的线程，通常用默认的即可。
handler：通常叫做拒绝策略，1、在线程池已经关闭的情况下。2、任务太多导致最大线程数和任务队列已经饱和，无法再接收新的任务。在上述两种情况下，只要满足一种，再使用execute()来提交新任务时将会被拒绝，而默认的拒绝策略是抛一个RejectedExecutionException异常。

3 线程池的使用

3.1 线程池使用步骤

1. 初始化一个线程池对象，一般是通过Executors工厂类来进行初始化。
2. 调用execute(...)方法

3.2 使用线程池的原因

• 线程的创建和销毁都需要时间，当有大量的线程创建和销毁时，那么这些时间的消耗则比较明显，将会导致性能上的缺失。
• 大量的线程创建、执行和销毁非常耗CPU和内存，这样将直接影响系统的吞吐量，导致性能急剧下降，如果内存资源占用的比较多，还可能造成OOM
• 大量线程的创建和销毁很容易导致GC频繁执行，从而发生内存抖动现象，对于移动端来说，最直观的体现就是造成界面卡顿。

3.3 线程池管理线程的优点

• 线程的创建和销毁由线程池维护，一个线程在完成任务后并不会立即销毁，而是由后续的任务复用这个线程，从而减少线程的创建和销毁，节约系统的开销。
• 线程池旨在线程的复用，这就可以节约我们用以往方式创建线程和销毁线程所消耗的时间，减少程序频繁调度的开销，从而节约系统资源，提高系统吞吐量。
• 在执行大量异步任务时提高了性能
• Java内置的一套ExecutorService线程池相关的api，可以更方便的控制线程的最大并发数、线程的定时任务、单线程的顺序执行等

3.4 newFixedThreadPool

创建一个固定的数量的线程池，示例如下：

 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3); 
 for (int i = 1; i <= 10; i++) { 
    final int index = i; 
    fixedThreadPool.execute(new Runnable() { 
        @Override 
        public void run() { 
            String threadName = Thread.currentThread().getName();
            Log.v("zxy", "线程："+threadName+",正在执行第" + index + "个任务"); 
            try { 
                Thread.sleep(2000); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    }); 
 }

上述代码，我们创建了一个线程数为3的固定线程数量的线程池，同理该线程池支持的线程最大并发数也是3，而我模拟了10个任务让它处理，执行的情况则是首先执行前三个任务，后面7个则依次进入任务队列进行等待，执行完前三个任务后，再通过FIFO的方式从任务队列中取任务执行，直到最后任务都执行完毕。
为了体现出线程的复用，我特地在Log中加上了当前线程的名称，效果为：

图3.1 newFixedThreadPool运行截图

3.5 newSingleThreadExecutor

创建一个只有一个线程的线程池，每次只能执行一个线程任务，多余的任务会保存到一个任务队列中，等待线程处理完再依次处理任务队列中的任务，示例为：

        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        for (int i = 1; i <= 10; i++) {
            final int index = i;
            singleThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.v("zxy", "线程："+threadName+",正在执行第" + index + "个任务");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

代码还是差不多，只不过改了线程池的实现方式，效果我想大家都知道，即依次一个一个的处理任务，而且都是复用一个线程，效果为：

图3.2 newSingleThreadExecutor运行截图

其实我们通过newSingleThreadExecutor()和newFixedThreadPool()的方法发现，创建一个singleThreadExecutorPool实际上就是创建一个核心线程数和最大线程数都为1的fixedThreadPool。

3.6 newCachedThreadPool

创建一个可以根据实际情况调整线程池中线程的数量的线程池，示例为：

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 1; i <= 10; i++) {
            final int index = i;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.v("zxy", "线程：" + threadName + ",正在执行第" + index + "个任务");
                    try {
                        long time = index * 500;
                        Thread.sleep(time);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

为了体现该线程池可以自动根据实现情况进行线程的重用，而不是一味的创建新的线程去处理任务，我设置了每隔1s去提交一个新任务，这个新任务执行的时间也是动态变化的，所以，效果为：

图3.3 newCachedThreadPool运行截图

可以看到，第二个任务复用了线程1，第三个任务来时，线程1还没执行完，所以创建了新的线程2，第四个任务来时线程1的任务执行完，所以又复用线程1，第5个任务来时，线程2的任务执行完，所以复用线程2，第6个任务来时，线程1的任务执行完，所以复用线程1，第7个任务来时，线程1，2的任务都没执行完，所以创建新的线程3，第8个任务来时，线程1，3的任务都没执行完，线程2的任务执行完，所以复用线程2，第9个任务来时，线程1空闲，复用线程1，第10个任务来时，线程1，2,3的任务都没执行完，所以创建新的线程4.

3.7 newScheduledThreadPool

创建一个可以定时或者周期性执行任务的线程池，示例为：

        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        //延迟2秒后执行该任务
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {

            }
        }, 2, TimeUnit.SECONDS);
        //延迟1秒后，每隔2秒执行一次该任务
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {

            }
        }, 1, 2, TimeUnit.SECONDS);

3.8 newSingleThreadScheduledExecutor

创建一个可以定时或者周期性执行任务的线程池，该线程池的线程数为1，示例为：

        ScheduledExecutorService singleThreadScheduledPool = Executors.newSingleThreadScheduledExecutor();
        //延迟1秒后，每隔2秒执行一次该任务
        singleThreadScheduledPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                Log.v("zxy", "线程：" + threadName + ",正在执行");
            }
        },1,2,TimeUnit.SECONDS);

实际上这个和上面的没什么太大区别，只不过是线程池内线程数量的不同，效果为：

图3.4 newSingleThreadScheduledExecutor运行截图

4 参考文章

https://blog.csdn.net/u010687392/article/details/49850803
https://www.jianshu.com/p/e66e9924a953