android的四种线程池

使用线程池的好处：

首先通过线程池中线程的重用，减少创建和销毁线程的性能开销。其次，能控制线程池中的并发数，否则会因为大量的线程争夺CPU资源造成阻塞。最后，线程池能够对线程进行管理，比如使用ScheduledThreadPool来设置延迟N秒后执行任务，并且每隔M秒循环执行一次。

 public ThreadPoolExecutor(int corePoolSize,

                              int maximumPoolSize,

                              long keepAliveTime,

                              TimeUnit unit,

                    BlockingQueue<Runnable> workQueue,

                          ThreadFactory threadFactory)

corePoolSize: 线程池中所保存的核心线程数。线程池初始化启动之后，默认是空的，只有当任务来临之时，才会建立线程处理请求。当然可以使用prestartCoreThread()方法可以使线程池初始化之后，立即建立corePoolSize个数的线程来等待任务。

maximumPoolSize: 线程池中线程数能达到的最大值。当然这个参数还与workQueue的使用策略有关，当使用无界队列(LinkedBlockQueue等)时，本参数无效。corePoolSize和maximumPoolSize的作用是控制线程池中实际运行线程的数目。例如当新的任务提交到线程池时，假设此时线程池中运行线程的数量为M，当M < corePoolSize时，会新建线程来处理任务；如果M>corePoolSize && M < maximumPoolSize时，如果是workQueue是阻塞队列时，才会创建新的线程来完成任务。如果corePoolSize == maximumPoolSize时，则意味着创建了固定大小的线程池。如果maximumPoolSize为Integer.MAX_VALUE，则可以理解为该线程池适合任意数量的并发任务。

keepAliveTime：当前线程池maximumPoolSize > corePoolSize时，终止（maximumPoolSize - corePoolSize）个空闲线程的时间。也就是说空闲状态下，（maximumPoolSize - corePoolSize）个线程存活的最长时间。

TimeUnit：keepAliveTime参数的时间单位，可以为毫秒，秒，分。。。

BlockingQueue: 任务队列，如果当前线程池中核心线程数达到了corePoolSize时，且当前所有线程都属于活动状态时，则将新的任务添加到该队列中。基本上有以下几个实现：
1) ArrayBlockQueue:基于数组结构的有界队列，此队列按FIFO(first in first out)原则对任务进行排序。如果队列已满，新的任务将会被采取拒绝策略对待。
2)LinkedBlockingQueue: 基于链表的无界队列，按FIFO原则排序。因为是无界的，所以不存在满的情况，此时拒绝策略无效
3) PriorityBlockingQueue：具有优先级的队列的有界队列，可以自定义优先级，默认为自然排序。

Handler：拒绝策略，当线程池和workQueue都满了的情况下，对新任务采取的处理策略，有四种默认实现：
1) AbortPolicy：拒绝任务，且还抛出RejectedExecutionException异常，线程池默认策略
2) CallerRunPolicy：拒绝新任务进入，如果该线程池还没有被关闭，那么这个新的任务在执行线程中被调用
3) DiscardOldestPolicy: 如果执行程序尚未关闭，则位于头部的任务将会被移除，然后重试执行任务(再次失败，则重复该过程)，这样将会导致新的任务将会被执行，而先前的任务将会被移除。
4）DiscardPolicy：没有添加进去的任务将会被抛弃，也不抛出异常。基本上为静默模式。

ThreadPoolExecutor的各个参数所代表的特性注释中已经写的很清楚了，那么ThreadPoolExecutor执行任务时的心路历程是什么样的呢？（以下用currentSize表示线程池中当前线程数量）

（1）当currentSize<corePoolSize时，没什么好说的，直接启动一个核心线程并执行任务。

（2）当currentSize>=corePoolSize、并且workQueue未满 时，添加进来的任务会被安排到workQueue中等待执行。

（3）当workQueue已满，但是currentSize<maximumPoolSize时，会立即开启一个非核心线程来执行任务。

（4）当currentSize>=corePoolSize、workQueue已满、并且currentSize>maximumPoolSize时，调用handler默认抛出RejectExecutionExpection异常。

1、FixedThreadPool （填充式线程池）只有核心线程，核心线程数固定，不回收不超时（核心线程没有超时机制），任务队列长度不限。（排队吃饭，餐位数量固定）

（适用于任务量比较固定但耗时长的任务）

 public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {

        return new ThreadPoolExecutor(nThreads, nThreads,

                                      0L, TimeUnit.MILLISECONDS,

                                      new LinkedBlockingQueue<Runnable>(),

                                      threadFactory);

    }

2、CachedThreadPool （缓存式线程池）没有核心线程，非核心线程随时创建，数量最大值为Integer.MAX_VALUE。空闲线程超时回收（60s）（适合执行大量耗时较小的任务）

public static ExecutorService newCachedThreadPool() {

        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                      60L, TimeUnit.SECONDS,

                                      new SynchronousQueue<Runnable>());

    }

3、ScheduledThreadPool 核心线程数量是固定的，而非核心线程是没有限制的，当非核心线程闲置时它会被立即回收（用于执行定时任务和具有固定时期的重复任务），

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {

        return new ScheduledThreadPoolExecutor(corePoolSize);

    }

 public ScheduledThreadPoolExecutor(int corePoolSize) {

        super(corePoolSize, Integer.MAX_VALUE,

              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,

              new DelayedWorkQueue());

    }

4、SingleThreadExecutor 只有一个核心线程，确保所有的任务都在同一个线程中按顺序执行。SingleThreadExecutor的意义在于统一所有外界任务在一个线程中，这使得这些任务之间不需要处理线程同步的问题。（使用于多个任务顺序执行的场景）

public static ExecutorService newSingleThreadExecutor() {

        return new FinalizableDelegatedExecutorService

            (new ThreadPoolExecutor(1, 1,

                                    0L, TimeUnit.MILLISECONDS,

                                    new LinkedBlockingQueue<Runnable>()));

    }

比较如下：