写作原因：Java或者Android开发者都知道，Java/Android中对于并发的控制是一个难点。如果控制不好线程问题，程序的稳定性难以得到保障。下面博主分享一下Android中线程池机制的基本内容。

原文链接：博主小屋

定义

这是Wikipedia对线程池的定义，看看即可：在计算机编程中，线程池包含一定数量的线程，这些线程用于并发地处理任务。通常情况下；反之，线程的数量根据可用的计算资源进行调整从而达到合理地并行处理任务即使任务的数量取决于问题本身并且在处理之前并不知道它们的确切情况。看不懂？没关系，下面通过具体案例来学习使用。

优势

使用线程池有以下一些优势：
（1）最大程度合理地使用线程，从而减少线程创建与销毁带来的性能开销。
（2）有效控制线程池的最大并发数，避免大量线程之间因为互相抢占系统资源而导致阻塞现象。
（3）能对线程进行简单的管理，并且提供定时执行以及指定间隔循环执行等功能。

ThreadPoolExecutor

下面先看看ThreadPoolExecutor

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

上面这段代码正是构成线程池的核心。Java几乎所有线程池都是直接或者间接使用ThreadPoolExecutor来实现的，这里先讲解一下这个线程池生成器的构成和运行模式，然后再讲解一下其构造方法相关形参的意义。
我个人把ThreadPoolExecutor理解成以下的模型，见下图：

ThreadPool1

根据上面这个模型来理解构造参数也就不难了。
int corePoolSize：设置核心线程的数量。
int maximumPoolSize：设置线程池最大线程容纳量，当活动线程数达到该值时，后续新任务会被阻塞。
long keepAliveTime：设置非核心线程闲置的超时时长，当allowCoreThreadTimeOut为True时同样会影响到核心线程。
TimeUnit unit：指定KeepAliveTime参数的时间单位。
BlockingQueue<Runnable> workQueue：超额Runnable对象（参见模型图）的储存地。
ThreadFactory threadFactory：提供创建新线程的功能。
此外还有一个不常用的参数TejectedExecutionHandler handler，主要用于通知任务执行失败的情况，具体使用讲解读者自行学习。

ThreadPoolExecutor怎么执行任务的呢？参见下面流程图：

ThreadPoolExecutor Run

四大线程池

定义及模型

四大线程池的创建采用了静态工厂模式（关于静态工厂模式以后有相关的博文），我们来看看它们的定义及创建时关键的源码，然后给出模型图。

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

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

ThreadPool2

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

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

ThreadPool3

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

ThreadPool4

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

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

ThreadPool5

使用

对于使用方法直接在源码中体现，源码已经足够通俗易懂，可以结合源码及上面的定义模型分析学习。

public class ThreadPool {
    private final static int SCHEDULED_DELAY = 0;
    private final static int SCHEDULED_AT_FIXED_RATE = 1;
    public static void main(String args[]){
        startCachedThreadPool();
        startFixedThreadPool();
        startScheduledThreadPool(SCHEDULED_DELAY);
        startScheduledThreadPool(SCHEDULED_AT_FIXED_RATE);
        startSingleThreadExecutor();
    }
    private static void startCachedThreadPool(){
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        //可缓存的线程池
        for(int i = 0;i<10;i++){
            final int index = i;
            try {
                Thread.sleep(index * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(index);
                    System.out.println("Thread's ID: "+Thread.currentThread().getId());
                }
            });
        }
        //线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
    }
    private static void startScheduledThreadPool(int status){
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        switch(status){
            case SCHEDULED_DELAY:
                scheduledThreadPool.schedule(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("delay 3 seconds");
                        System.out.println("Thread's ID: "+Thread.currentThread().getId());
                    }
                },3, TimeUnit.SECONDS);
                break;
            case SCHEDULED_AT_FIXED_RATE:
                scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("delay 1 seconds,and excute every 3 seconds");
                        System.out.println("Thread's ID: "+Thread.currentThread().getId());
                    }
                },1,3,TimeUnit.SECONDS);
                //不一定使用同一个线程来发送。
                break;
        }

    }
    private static void startFixedThreadPool(){
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for(int i =0;i<10;i++){
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(index);
                        System.out.println("Thread's ID: "+Thread.currentThread().getId());
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
    private static void startSingleThreadExecutor(){
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for(int i = 0;i<10;i++){
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(index);
                        System.out.println("Thread's ID: "+Thread.currentThread().getId());
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

总结

到此处博主大概梳理了一遍线程池的基本知识，如果有疏漏或者错误的地方求指正！