android的四种线程池

四种线程池内部构造都是来自同一个方法：

 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：没有添加进去的任务将会被抛弃，也不抛出异常。基本上为静默模式。

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>()));
    }

比较如下：