多线程之线程池介绍

一.Android多线程：线程池理解和使用总结

-----

一.android中的线程池

线程池的好处

(1)重用线程池中的线程，避免因为线程的创建和销毁所带来的性能的开销。
(2)能有效控制线程池的最大并发数，避免线程间因抢占系统资源而导致线程阻塞。
(3)能够对线程进行管理，并提供定时执行及指定间隔循环执行等功能

线程池的配置

ThreadPoolExecutor是线程池的正真实现

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

corePoolSize

线程池的核心线程数，默认情况下，核心线程在线程池中一直存活。如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，那么闲置的核心线程会有超时策略，这个时间由keepAliveTime所指定，当时间超过keepAliveTime所指定的时间后，核心线程就会被终止。

maximumPoolSize

线程池所能容纳的最大线程数，当活动线程数达到这个值后，后续任务将会被阻塞。

keepAliveTime

非核心线程闲置时的超时时长，超过这个时间，非核心线程就会被回收。如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，keepAliveTime同样会作用于核心线程

unit

keepAliveTime参数的时间单位，是一个枚举类型,常用的有TimeUnit.MILLISECONDS(毫秒)、TimeUnit.SECONDS(秒)、TimeUnit.MINUTES(分钟)等

BlockingQueue<Runnable> workQueue

线程池中的任务队列，通过线程池的execute方法提交的Runnable对象存储在这个参数中。

threadFactory

线程工厂，为线程池提供创建线程的功能。ThreadFactory是一个接口，只有一个方法 Thread new Thread(Runnable runnable)

ThreadPoolExecutor执行任务时的规则：

(1)如果线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行任务。

(2)如果线程池中的线程数量已达到或者超过核心线程的数量，那么任务会被插入到任务队列中排队等待执行。

(3)如果无法将任务插入任务队列中(任务队列已满)，这时候如果线程池中的线程数量未达到线程池规定的最大值，那么会立刻启动一个非核心线程来执行任务。

ThreadPoolExecutor在AsyncTask中的配置

用于AsyncTask封装了线程池，我们从AsyncTask源码中可以看出AsyncTask对ThreadPoolExecutor的配置

public abstract class AsyncTask<Params, Progress, Result>
{
    private static final String LOG_TAG = "AsyncTask";
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    // We want at least 2 threads and at most 4 threads in the core pool,
    // preferring to have 1 less than the CPU count to avoid saturating
    // the CPU with background work
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 30;

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

    /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

线程池的分类

Android中四类具有不同功能特征的线程池，它们都直接或者间接地通过配置ThreadPoolExecutor来实现自己的功能特性

FixedThreadPool

通过Executors的newFixedThreadPool来创建

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

是一种线程数量固定的线程池，当线程处于空闲状态时，不会被回收，当所有线程都处于活动状态时，新任务将处于等待状态，直到有线程空闲出来。FixedThreadPool中只有核心线程并且核心线程没有超时限制

newCachedThreadPool

通过Executors的newCachedThreadPool来创建

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

可以看出它没有核心线程，线程数量不定Integer.MAX_VALUE，超时时长为60秒，比较适合执行大量的耗时较少的任务。

ScheduledThreadPool

通过Executors的newScheduledThreadPool来创建

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

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

核心线程数量是固定的，非核心线程的数量没有限制，并且非核心线程闲置时会被立即回收。主要用于执行定时任务和具有固定周期的重复任务。

SingleThreadExecutor

通过Executors的newSingleThreadExecutor来创建

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

只有一个核心线程，它确保所有的任务都在同一个线程中按顺序执行。不需要处理线程同步的问题。

作者：蓝枫zeke
链接：http://events.jianshu.io/p/45b98199af4a

二. 线程池理解和使用总结

1、Android线程池介绍

1.1 原理

Android的线程池来源于Java中Executor，Executor是一个接口，真正线程实现ThreadPoolExecutor。

（ThreadPoolExecutor继承AbstractExecutorService，AbstractExecutorService继承ExecutorService，ExecutorService继承Executor接口）。

1.2 分类

FixedThreadPool(线程数量固定)、
CachedThreadPool(线程数量不定)、
ScheduledThreadPool(核心线程数量固定，非核心线程数量无限制)、
SingleThreadExecutor(只有一个核心线程，所有任务在里面按顺序执行)。

1.3 优点

重用线程池中的线程，避免频繁创建和销毁线程所带来的内存开销。
有效控制线程最大并发数，避免因线程之间抢占资源而导致阻塞现象。
能够对线程进行简单的管理，提供定时执行以及指定时间间隔循环执行等功能。

线程池的作用：
线程池作用就是限制系统中执行线程的数量。
根据系统环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池？
减少创建和销毁线程次数，每个工作线程都可以被重复利用，可执行多个任务
可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)

一般会开启线程去处理耗时任务，一个线程run()执行完毕后结束，但并没有被回收，会一直闲置在那里，等待GC去回收。

所以如果每执行一个任务都new一个线程，那么在某些极端的场景下，是比较消耗内存的。那么对于线程也有个线程池。

2、 Android线程池分类

由于Android线程池都是直接或间接通过配置ThreadPoolExecutor实现的，因此先介绍ThreadPoolExecutor。

2.1. ThreadPoolExecutor介绍

ThreadPoolExecutor比较常用构造方法。

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue, 
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler);
}

corePoolSize：线程池核心线程数，默认核心线程会一直存活于线程池，即使处闲置状态。如果设置ThreadPoolExecutor的allowCoreThreadTimeOut为True，则核心线程在等待新任务到来时会有超时终止策略。超时时间由keepAliveTime决定。

 private volatile long keepAliveTime;
 private volatile boolean allowCoreThreadTimeOut;

maximumPoolSize：线程池能容纳最大线程数，当线程数达到这个数值后，后续新任务将会被阻塞。
keepAliveTime：非核心线程超时时长，超过这个时间没有任务执行，非核心线程就会被回收。当核心线程设置allowCoreThreadTimeOut为true时，keepAliveTime同样作用于核心线程。
unit：指定keepAliveTime参数时间单位，这是一个枚举。有TimeUnit.MILLISECONDS（毫秒）TimeUnit.SECOUNDS（秒）等
workQueue：线程池中任务队列，通过线程池execute()提交的Runnable对象会存储在这个参数中。
threadFactory：线程工厂，为线程池提供创建新线程功能。ThreadFactory一个接口，它只有一个方法：Thread newThread(Runnable r);
handler：该handler类型为RejectedExecutionHandler。这个参数不常用，它的作用是当线程池无法执行新任务时，会调用handler的rejectedExecution(Runnable r, ThreadPoolExecutor e)来抛出异常。无法执行原因可能是由于队列满或者任务无法成功执行等。

* ThreadPoolExecutor执行任务大致遵循规则：
（1）如果线程池中线程数量未达到核心线程的数量，会直接启动一个核心线程来执行任务。
（2）如果线程池中的线程数量已经达到或者超过核心线程的数量，那么任务会被插入到任务队列中排队等待执行。
（3）如果第2步中无法插入新任务，说明任务队列已满，如果未达到规定的最大线程数量，则启动一个非核心线程来执行任务。
（4）如果第3步中线程数量超过规定的最大值，则拒绝任务并使用RejectedExecutionHandler的rejectedExecution(Runnable r, ThreadPoolExecutor e)方法来通知调用者。

ThreadPoolExecutor执行任务时需要遵循如下规则：

如果线程池中的线程数量已经达到或超过核心线程数，并且任务队列已满，这个时候如果线程池中的线程数量未达到线程池规定的最大值，那么会立即启动一个非核心线程来执行任务；
如果步骤3中线程数量达到线程池规定的最大值，那么就拒绝执行此任务，会调用RejectedExecutionHandler的rejectedExecution方法来通知调用者任务执行请求被拒绝。

处理任务优先级排序：启动核心线程 -> 进入任务队列 -> 启动非核心线程。

2.2 线程池的分类

先介绍一个类Executors，这个类定义各种参数用于创建多种线程池，最终实现还是通过ThreadPoolExecutor类。

第二节对ThreadPoolExecutor的主要参数介绍，本节介绍Android常见线程池，通过配置ThreadPoolExecutor实现自己特性。除了系统提供这几类线程池之外，我们也可以根据实际场景灵活地配置线程池。

1. FixedThreadPool （Fixed：固定的，不变的。参数为核心线程数，只有核心线程，无非核心线程，并且是阻塞队列无界）
通过Executors的newFixedThreadPool创建，通过创建时的参数可以看出又以下几个特点：

线程数量固定且都是核心线程：核心线程数量和最大线程数量都是nThreads（核心线程数=最大线程数(即线程池中只有核心线程，意味所有线程不会被回收，除非线程池被关闭）；
都是核心线程且不会被回收，快速响应外界请求；
没有超时机制，任务队列也没有大小限制；
新任务使用核心线程处理，如果没有空闲的核心线程，则排队等待执行(当所有线程都处于活动状态时，由于任务队列没有限制大小，因此新任务总是会进入任务队列排队等待，直到有线程空闲出来)。

public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
}
Android sdk源码用的比较多的，可设置线程池最大值。如果超过这个最大值，那么任务会加入任务队列去等待。
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
fixedThreadPool.execute(new Runnable() {... });

2. CachedThreadPool （缓存,按需创建。因为没有核心线程，其他全为非核心线程）
通过Executors的newCachedThreadPool创建，特点：

线程数量不定，只有非核心线程，最大线程数任意大：传入核心线程数量的参数为0，最大线程数为Integer.MAX_VALUE；
有新任务时使用空闲线程执行，没有空闲线程则创建新的线程来处理(CachedThreadPool任务队列实际上是一个无法存储任务的队列，将导致任何任务都会立即被执行)。
该线程池的每个空闲线程都有超时机制，时常为60s（参数:60L），空闲超过60s则回收空闲线程。
适合执行大量的耗时较少的任务，当所有线程闲置超过60s都会被回收，所以这时几乎不占用系统资源。

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

这种线程池比较灵活，也就是它的池里的线程数量并不是固定的，理论上可以无限大，任务不需要排队。如果有空闲的线程，则复用，无则新建线程。
ExecutorService cachedThreadPool =Executors.newCachedThreadPool();
cachedThreadPool.execute(new Runnable() {.....});

CachedThreadPool :
SynchronousQueue是不存储元素的，每次插入操作必须伴随一个移除操作，一个移除操作也要伴随一个插入操作。
当一个任务执行时，先用SynchronousQueue的offer提交任务，
如果线程池中有线程空闲，则调用SynchronousQueue的poll()来移除任务并交给线程处理；如果没有线程空闲，则开启一个新的非核心线程来处理任务。
由于maximumPoolSize是无界的，所以如果线程处理任务速度小于提交任务的速度，则会不断地创建新的线程，这时注意不要过度创建，应采取措施调整双方速度，不然线程创建太多会影响性能。
使用场景：从其特点看出，CachedThreadPool适用于有大量需要立即执行的耗时少的任务的情况。

3. ScheduledThreadPool（Scheduled：预定的、排定的）用来创建一个定长线程池，并且支持定时和周期性的执行任务。
通过Executors的newScheduledThreadPool创建，特点：

核心线程数量固定，非核心线程数量无限制；
非核心线程闲置超过10s会被回收；
主要用于执行定时任务和具有固定周期的重复任务；

唯一一个有延时执行和周期重复执行的功能：创建时

ScheduledThreadPoolExecutor(corePoolSize)返回new ScheduledThreadPoolExecutor，

ScheduledThreadPoolExecutor是ThreadPoolExecutor子类，DelayedWorkQueue是ScheduledThreadPoolExecutor一个静态内部类，主要处理任务队列延迟的工作。

//延迟1秒执行，每隔1秒向线程池提交一次任务
Executors. newScheduledThreadPool (5).scheduleAtFixedRate(runnable, 1, 1, TimeUnit.SECONDS);

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
 return new ScheduledThreadPoolExecutor(corePoolSize);
}
 //默认闲置超时回收时常
private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS, new DelayedWorkQueue());
}

//延迟1s启动任务
scheduledThreadPool.schedule(runnable,1,TimeUnit.SECONDS);
//延迟5s后启动，每1s执行一次
scheduledThreadPool.scheduleAtFixedRate(runnable,5,1,TimeUnit.SECONDS);
//启动后第一次延迟5s执行，后面延迟1s执行
scheduledThreadPool.scheduleWithFixedDelay(runnable,5,1,TimeUnit.SECONDS);

4. SingleThreadExecutor （单线程线程池）
通过Executors.newSingleThreadExecutor()创建，特点：

只有一个核心线程(核心线程数=最大线程数=1），所有任务在同一个线程按顺序执行。
所有的外界任务统一到一个线程中，所以这些任务不需要处理线程同步问题。

用来创建一个单线程化的线程池，它只用唯一的工作线程来执行任务，一次只支持一个，所有任务按照指定的顺序执行。
这是一个单例化的线程池，他只有一个线程去执行任务。场景：最常见例子就是我们的UI线程，典型单线程模型。

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

2.1 线程池其它方法：
1.shutDown() 关闭线程池，不影响已经提交的任务
2.shutDownNow() 关闭线程池，并尝试去终止正在执行的线程
3.allowCoreThreadTimeOut(boolean value) 允许核心线程闲置超时时被回收
4.submit 一般情况下我们使用execute来提交任务，但是有时候可能也会用到submit，使用submit的好处是submit有返回值。
5.beforeExecute() - 任务执行前执行的方法
6.afterExecute() -任务执行结束后执行的方法
7.terminated() -线程池关闭后执行的方法

Executor框架最核心的类是ThreadPoolExecutor，它是线程池的实现类，主要由4个组件构成。
·corePool：核心线程池的大小。
·maximumPool：最大线程池的大小。
·BlockingQueue：用来暂时保存任务的工作队列。
·RejectedExecutionHandler：当ThreadPoolExecutor已经关闭或ThreadPoolExecutor已经饱和时（达到了最大线程池大小且工作队列已满），execute()方法将要调用的Handler。
通过Executor框架的工具类Executors，可以创建3种类型的ThreadPoolExecutor。

2.2 各个线程池总结及适用场景

newFixedThreadPool：
底层：返回ThreadPoolExecutor实例，接收参数为所设定线程数量nThread，corePoolSize为nThread，maximumPoolSize为nThread；keepAliveTime为0L(不限时)；unit为：TimeUnit.MILLISECONDS；
WorkQueue为：new LinkedBlockingQueue<Runnable>() 无解阻塞队列：
通俗：创建可容纳固定数量线程的池子，每隔线程的存活时间是无限的，当池子满了就不再添加线程了；如果池中的所有线程均在繁忙状态，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：执行长期的任务，性能好很多

newCachedThreadPool：
底层：返回ThreadPoolExecutor实例，corePoolSize为0；maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为60L；unit为TimeUnit.SECONDS；workQueue为SynchronousQueue(同步队列)
通俗：当有新任务到来，则插入到SynchronousQueue中，由于SynchronousQueue是同步队列，因此会在池中寻找可用线程来执行。
若有可以线程则执行，若没有可用线程则创建一个线程来执行该任务；若池中线程空闲时间超过指定大小，则该线程会被销毁。
适用：执行很多短期异步的小程序或者负载较轻的服务器

newScheduledThreadPool:
底层：创建ScheduledThreadPoolExecutor实例，corePoolSize为传递来的参数，maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为0；unit为：TimeUnit.NANOSECONDS；
workQueue为：new DelayedWorkQueue() 一个按超时时间升序排序的队列：
通俗：创建一个固定大小的线程池，线程池内线程存活时间无限制，线程池可以支持定时及周期性任务执行，如果所有线程均处于繁忙状态，对于新任务会进入DelayedWorkQueue队列中，这是一种按照超时时间排序的队列结构
适用：周期性执行任务的场景

newSingleThreadExecutor:
底层：FinalizableDelegatedExecutorService包装的ThreadPoolExecutor实例，corePoolSize为1；maximumPoolSize为1；keepAliveTime为0L；unit为：TimeUnit.MILLISECONDS；
workQueue为：new LinkedBlockingQueue<Runnable>() 无解阻塞队列：
通俗：创建只有一个线程的线程池，且线程的存活时间是无限的；当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：一个任务一个任务执行的场景

3、Android线程池简单使用

3.1 线程池简单使用

(1)上面所说的四种常用线程池的实例化：
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(1);
fixedThreadPool.execute(runnable);
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
cachedThreadPool.execute(runnable);
//线程4
// 注意这里创建的是ScheduledExecutorService对象，ScheduledExecutorService是ExecutorService的子类
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
// 延迟1000ms后执行runnable
scheduledThreadPool.schedule(runnable,1000,TimeUnit.MILLISECONDS);//定时执行
// 延迟1000ms后，每2000ms执行一次runnable
scheduledThreadPool.scheduleAtFixedRate(runnable,1000,2000,TimeUnit.MILLISECONDS);//周期执行
isRunning = true;
(2)demo：
添加线程池开始执行和ScheduledThreadPool停止执行的两个按钮点击事件，布局就不贴了。
findViewById(R.id.btn_start).setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
count = 0;
mStatueText.setText("线程开始执行，次数："+ count);
startThreadPool();
}});
findViewById(R.id.btn_stop).setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
if(null != scheduledThreadPool && isRunning){
scheduledThreadPool.shutdown();
mStatueText.setText("scheduledThreadPool线程停止，当前次数："+ count);
isRunning = false;
}
}});
startThreadPool(); 方法里Runnable每执行一次增加一次count并打到TextView上：
Runnable runnable = new Runnable() {
@Override
public void run() {
count++;
runOnUiThread(new Runnable() {
@Override
public void run() {
mStatueText.setText("线程执行完毕，次数："+ count);
}
});}};

接着让所有的线程池执行这个Runnable对象，最后的结果是变量count的值从0直接到了3，然后又到5最后无限增长。

原因是除ScheduledThreadPool对象外的三个线程池很快执行了任务，ScheduledThreadPool对象的执行了两次任务，两个都延时1000ms。

最后循环执行的任务一直在增加count的值。

三. Android 线程池原理及使用

1.1 线程池介绍
什么是线程池
线程池就是一个可以同时容纳多个线程执行的容器。
线程池优点：
a.通过重用线程池中的线程，可以避免因重复创建和销毁线程带来的性能开销；
b.有效控制线程的最大并发数，避免大量的线程因互相抢占资源而造成系统的阻塞；
c.能够对线程进行简单的管理，提供定时执行、间隔循环执行等功能。

使用线程池的原因
如果用传统newThread创建一个子线程进行处理，会造成一些严重的问题：
1：在多任务的情况下，系统要为每一个任务创建一个线程，而任务执行完毕后会销毁每一个线程，所以会造成线程频繁地创建与销毁。
2：多个线程频繁地创建会占用大量的资源，并且在资源竞争的时候就容易出现问题，同时这么多的线程缺乏一个统一的管理，容易造成界面的卡顿。
3:多个线程频繁地销毁，会频繁地调用GC机制，这会使性能降低，又非常耗时。
总而言之：频繁地为每一个任务创建一个线程，缺乏统一管理，降低性能，并且容易出现问题。为了解决这些问题，就要用线程池.

线程池使用的好处：
1：(重点)对线程进行复用，线程在执行完任务后不会立刻销毁，而会等待另外的任务，这样就不会频繁创建、销毁线程和调用GC。
2：对多个线程进行统一地管理，避免资源竞争中出现的问题。
3：JAVA提供了一套完整的ExecutorService线程池创建的api，可创建多种功能不一的线程池，使用起来很方便。

2.3 ThreadPoolExecutor 创建基本线程池

创建线程池，主要是利用ThreadPoolExecutor这个类，而这个类有几种构造方法，其中参数最多的一种构造如下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory) {
  ...
}
corePoolSize: 该线程池中核心线程的数量。
maximumPoolSize：该线程池中最大线程数量。(区别于corePoolSize)
keepAliveTime:从字面上就可以理解，是非核心线程空闲时要等待下一个任务到来的时间，当任务很多，每个任务执行时间很短的情况下调大该值有助于提高线程利用率。
注意：当allowCoreThreadTimeOut属性设为true时，该属性也可用于核心线程。
unit:上面时间属性的单位
workQueue:任务队列，后面详述。
threadFactory:线程工厂，可用于设置线程名字等等，一般无须设置该参数。
设置好几个参数就可以创建一个基本的线程池，而之后的各种线程池都是在这种基本线程池的基础上延伸的。
下面贴个demo来熟悉具体的使用并且加深影响：
//创建基本线程池
final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3,5,1,TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(100));
设置一个按钮mThreadPoolExecute，并在点击事件中使用线程池

mThreadPoolExecute.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
for(int i = 0;i<30;i++){
final int finali = i;
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
Log.d("Thread", "run: "+finali);
Log.d("当前线程：",Thread.currentThread().getName());
}
}
};
threadPoolExecutor.execute(runnable);
}
}});

结果会每2s打印三个日志。

具体过程：

1.execute一个线程之后，如果线程池中的线程数未达到核心线程数，则会立马启用一个核心线程去执行。

2.execute一个线程之后，如果线程池中的线程数已经达到核心线程数，且workQueue未满，则将新线程放入workQueue中等待执行。

3.execute一个线程之后，如果线程池中的线程数已经达到核心线程数但未超过非核心线程数，且workQueue已满，则开启一个非核心线程来执行任务。

4.execute一个线程之后，如果线程池中的线程数已经超过非核心线程数，则拒绝执行该任务，采取饱和策略，并抛出RejectedExecutionException异常。

demo中设置的任务队列长度为100，所以不会开启额外的5-3=2个非核心线程，如果将任务队列设为25，则前三个任务被核心线程执行，剩下的30-3=27个任务进入队列会满，此时会开启2个非核心线程来执行剩下的两个任务。

//新开启了thread-4与thread-5执行剩下的超出队列的两个任务28和29
2019-03-28 15:54:07.879 22284-22618/com.example.threadpooltest D/Thread:: 1
2019-03-28 15:54:07.879 22284-22617/com.example.threadpooltest D/Thread:: 0
2019-03-28 15:54:07.879 22284-22617/com.example.threadpooltest D/当前线程：: pool-1-thread-1
2019-03-28 15:54:07.879 22284-22618/com.example.threadpooltest D/当前线程：: pool-1-thread-2
2019-03-28 15:54:07.880 22284-22619/com.example.threadpooltest D/Thread:: 2
2019-03-28 15:54:07.880 22284-22619/com.example.threadpooltest D/当前线程：: pool-1-thread-3
2019-03-28 15:54:07.881 22284-22620/com.example.threadpooltest D/Thread:: 28
2019-03-28 15:54:07.881 22284-22620/com.example.threadpooltest D/当前线程：: pool-1-thread-4
2019-03-28 15:54:07.881 22284-22621/com.example.threadpooltest D/Thread:: 29
2019-03-28 15:54:07.881 22284-22621/com.example.threadpooltest D/当前线程：: pool-1-thread-5

疑问：每个for循环里都有一个sleep（2000），为何会每隔2s打印三个任务？
原因：因为一开始的时候只是声明runnable对象并且重写run()方法，并没有运行，而后execute(runnable) 才会sleep，又因为一开始创建线程池的时候声明的核心线程数为3，所以会首先开启三个核心线程，然后执行各自的run方法，虽然有先后顺序，但这之间的间隔很短，所以2s后同时打印3个任务。

2.4 ThreadPoolExecutor介绍

Android中线程池真正实现是ThreadPoolExecutor类，它的构造方法提供一系列参数来配置线程池，了解各个参数的含义。

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

corePoolSize
线程池的核心线程数，默认情况下，核心线程会在线程池中一直存活，即使它们处于空闲状态。但是当ThreadPoolExecutor的allowCoreThreadTimeOut属性值为true，那么空闲的核心线程也会有超时策略，这个时长由keepAliveTime决定，当等待超过keepAliveTime指定的时长，核心线程被终止。
maximumPoolSize
线程池能容纳的最大线程数，当线程数达到这个数值，后续的任务会被阻塞，直到有其他线程被释放。
keepAliveTime
非核心线程的闲置超时时长，超过这个时长非核心线程就会被回收。当ThreadPoolExecutor的allowCoreThreadTimeOut属性值为true，keepAliveTime同样会作用于核心线程。
unit
设置keepAliveTime参数的单位。
workQueue
线程池中的任务队列，通过线程池的execute方法提交的Runnable对象会存储在这个参数中。
threadFactory
线程工厂，专门为线程池生成新线程。

处理任务优先级排序：启动核心线程 -> 进入任务队列 -> 启动非核心线程。

源码角度分析一下任务执行规则：

public void execute(Runnable command) {
   //传进来的线程为null，则抛出空指针异常
   if (command == null)
       throw new NullPointerException();
  
   //获取当前线程池的状态+线程个数变量
   int c = ctl.get();
    //3个步骤

   //1.判断当前线程池线程个数是否小于corePoolSize,小于则调用addWorker方法创建新线程运行,且传进来的Runnable当做第一个任务执行。
   //如果调用addWorker方法返回false，则直接返回
   if (workerCountOf(c) < corePoolSize) {
       if (addWorker(command, true))
           return;
       c = ctl.get();
   }

   //2.如果线程池处于RUNNING状态，则添加任务到阻塞队列
   if (isRunning(c) && workQueue.offer(command)) {
       //二次检查
       int recheck = ctl.get();
       //如果当前线程池状态不是RUNNING则从队列删除任务，并执行拒绝策略
       if (! isRunning(recheck) && remove(command))
           reject(command);
       //否者如果当前线程池线程空，则添加一个线程
       else if (workerCountOf(recheck) == 0)
           addWorker(null, false);
   }
   //3.新增线程，新增失败则执行拒绝策略
   else if (!addWorker(command, false))
       reject(command);
}

这样直接看代码可能还是不太清晰，所以直接看图比较容易理解具体过程。参考《Android开发艺术探索》

2.5 自定义的PriorityThreadPool(队列中有优先级比较的线程池)

 //创建自定义线程池(优先级线程)
final ExecutorService priorityThreadPool = new ThreadPoolExecutor(3,3,0, TimeUnit.SECONDS,new PriorityBlockingQueue<Runnable>());
自定义Runnable，继承Comparable接口：
public abstract class PriorityRunnable implements Runnable,Comparable<PriorityRunnable> {
    private int priority;
    public  PriorityRunnable(int priority){
        if(priority <0) {
            throw new IllegalArgumentException();
        }
        this.priority = priority;
    }
    public int getPriority() {
        return priority;
    }
    @Override
    public int compareTo(@NonNull PriorityRunnable another) {
        int me = this.priority;
        int anotherPri=another.getPriority();
        return me == anotherPri ? 0 : me < anotherPri ? 1 : -1;
    }
    @Override
    public void run() {
            doSomeThing();
    }
    protected abstract void doSomeThing();
}
利用抽象类继承Comparable接口重写其中的compareTo方法来比较优先级。
使用：
  mMyPriorityTheadPool.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                for(int i = 0;i<30;i++){
                    final int priority = i;
                    priorityThreadPool.execute(new PriorityRunnable(priority) {
                        @Override
                        protected void doSomeThing() {
                            Log.d("MainActivity", "优先级为 "+priority+"  的任务被执行");
                            try {
                                Thread.sleep(2000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    });
                }
            }
        });

结果：前三个任务被创建的三个核心线程执行，之后的27个任务进入队列并且调用compareTo方法进行排序，之后打印出来的是经过排序后从大到小的顺序。

四. 线程池的分类：

1.线程池的分类

1. FixedThreadPool被称为可重用固定线程数的线程池。

FixedThreadPool的corePoolSize和maximumPoolSize都被设置为创建FixedThreadPool时指定的参数nThreads。

当线程池中的线程数大于corePoolSize时，keepAliveTime为多余的空闲线程等待新任务的最长时间，超过这个时间后多余的线程将被终止。这里把keepAliveTime设置为0L，意味着多余的空闲线程会被立即终止。

FixedThreadPool的execute()方法的运行示意图如图所示。

1）如果当前运行的线程数少于corePoolSize，则创建新线程来执行任务。

2）在线程池完成预热之后（当前运行的线程数等于corePoolSize），将任务加入 LinkedBlockingQueue。

3）线程执行完1中的任务后，会在循环中反复从LinkedBlockingQueue获取任务来执行。

FixedThreadPool使用无界队列LinkedBlockingQueue作为线程池的工作队列（队列的容量为 Integer.MAX_VALUE）。使用无界队列作为工作队列会对线程池带来如下影响。

1）当线程池中的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数不会超过 corePoolSize。

2）由于1，使用无界队列时maximumPoolSize将是一个无效参数。

3）由于1和2，使用无界队列时keepAliveTime将是一个无效参数。

4）由于使用无界队列，运行中的FixedThreadPool（未执行方法shutdown()或 shutdownNow()）不会拒绝任务（不会调用RejectedExecutionHandler.rejectedExecution方法）。

2. CachedThreadPool详解: CachedThreadPool是一个会根据需要创建新线程的线程池。

下面是创建CachedThreadPool源码。

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,new SynchronousQueue());

}

CachedThreadPool的corePoolSize被设置为0，即corePool为空；maximumPoolSize被设置为 Integer.MAX_VALUE，即maximumPool是无界的。

这里把keepAliveTime设置为60L，意味着 CachedThreadPool中的空闲线程等待新任务的最长时间为60秒，空闲线程超过60秒后将会被终止。

FixedThreadPool和SingleThreadExecutor使用无界队列LinkedBlockingQueue作为线程池的工作队列。CachedThreadPool使用没有容量的SynchronousQueue作为线程池的工作队列，但 CachedThreadPool的maximumPool是无界的。这意味着，如果主线程提交任务的速度高于 maximumPool中线程处理任务的速度时，CachedThreadPool会不断创建新线程。极端情况下， CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源。

CachedThreadPool的execute()方法的执行示意图如图所示。

对上图的说明如下。

1）首先执行SynchronousQueue.offer（Runnable task）。如果当前maximumPool中有空闲线程正在执行 SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS），那么主线程执行offer操作与空闲线程执行的poll操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成；否则执行下面的步骤

2）当初始maximumPool为空，或者maximumPool中当前没有空闲线程时，将没有线程执行 SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS）。这种情况下，步骤1）将失败。此时CachedThreadPool会创建一个新线程执行任务，execute()方法执行完成。

3）在步骤2）中新创建的线程将任务执行完后，会执行 SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS）。这个poll操作会让空闲线程最多在SynchronousQueue中等待60秒钟。如果60 秒钟内主线程提交了一个新任务（主线程执行步骤1）），那么这个空闲线程将执行主线程提交的新任务；否则，这个空闲线程将终止。由于空闲60秒的空闲线程会被终止，因此长时间保持空闲的CachedThreadPool不会使用任何资源。

前面提到过，SynchronousQueue是一个没有容量的阻塞队列。每个插入操作必须等待另一个线程的对应移除操作，反之亦然。CachedThreadPool使用SynchronousQueue，把主线程提交的任务传递给空闲线程执行。CachedThreadPool中任务传递的示意图如图所示。

3.SingleThreadExecutor详解

SingleThreadExecutor是使用单个worker线程的Executor。下面是SingleThreadExecutor的源代码实现。

public static ExecutorService newSingleThreadExecutor() {

return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS ,new LinkedBlockingQueue()));

}

SingleThreadExecutor的corePoolSize和maximumPoolSize被设置为1。其他参数与 FixedThreadPool相同。SingleThreadExecutor使用无界队列LinkedBlockingQueue作为线程池的工作队列（队列的容量为Integer.MAX_VALUE）。

SingleThreadExecutor使用无界队列作为工作队列对线程池带来的影响与FixedThreadPool相同，这里就不赘述了。

SingleThreadExecutor的运行示意图如图。