这是一篇迟来的文章，从上一篇文章开始，就说要介绍Executor，但是由于有事一直>拖了好久，如果还没有看过上一篇文章的用户，可以阅读一下Android异步处理的几>种方式。

Excutor

Excutor实质上只是一个接口而已，所以我们可以建立一个类用来实现这个Excutor。

public class MyExecutor implements Executor{
    @Override
    public void execute(Runnable runnable) {
        new Thread(runnable).start();
    }
}

当然对Executor简单的实现，意义并不是很大，我们需要的是对每个任务的控制和调度，这样，通常需要增加队列，以及优先级的功能。这也就是所谓的线程池，线程池是任务队列和线程的集合。好了下面一个个说。

ExecutorService

ExecutorService提供了管理终止的方法，以及可以跟踪一个或多个异步任务执行状况而生成 Future 的接口。

Paste_Image.png

根据图中列出的方法可以看到，提供了关闭的方法shutdownNow() ， shutdownNow() 方法阻止等待任务的启动并试图停止当前正在执行的任务。在终止后，执行程序没有任务在执行，也没有任务在等待执行，并且无法提交新任务。
我们可以看一下继承实现关系

Paste_Image.png

ThreadPoolExecutor

根据上面的继承关系可知，ThreadPoolExecutor其实就是Executor的拓展，增加了一些新的控制方法。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, 
TimeUnit unit, BlockingQueue workQueue, 
ThreadFactory threadFactory, RejectedExecutionHandler handler)

corePoolSize：线程池维护线程的最少数量
maximumPoolSize：线程池维护线程的最大数量
keepAliveTime：线程池维护线程所允许的空闲时间
unit：线程池维护线程所允许的空闲时间的单位
workQueue：线程池所使用的缓冲队列

handler：线程池对拒绝任务的处理策略

现在对上面的参数详细解释一下：
如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。
也就是处理任务的优先级为：
*核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。 *
当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。
handler有四个选择：

ThreadPoolExecutor.AbortPolicy()
抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()
重试添加当前的任务，他会自动重复调用execute()方法
ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务
这个地方如果不明白，可以下载这篇文章最后的demo，修改几个参数，对照log看一下，就能明白。

    private void threadPoolEcecutor(){
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 15, 15, TimeUnit.SECONDS, new ArrayBlockingQueue(3),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 0 ;i<15;i++){
            final String name = "第"+i+"个线程";
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.e(TAG,name+"0s");
                    try {
                        Thread.sleep(1000);
                        Log.e(TAG,name+"1s");
                        Thread.sleep(1000);
                        Log.e(TAG,name+"2s");
                        Thread.sleep(1000);
                        Log.e(TAG,name+"3s");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

        }
    }

Executors

线程池还可以通过Executors的工厂方法配置，主要有一下四种：

newFixedThreadPool

private void fixEcecutor(){
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0 ;i<15;i++){
            final String name = "第"+i+"个线程";
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.e(TAG,name+"0s");
                    try {
                        Thread.sleep(1000);
                        Log.e(TAG,name+"1s");
                        Thread.sleep(1000);
                        Log.e(TAG,name+"2s");
                        Thread.sleep(1000);
                        Log.e(TAG,name+"3s");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

        }
    }

这种形式可以控制最大并发数量，超出的线程会等待。
如下图所示：

log

newSingleThreadExecutor

 private void singleEcecutor(){
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0 ;i<15;i++){
            final String name = "第"+i+"个线程";
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    Log.e(TAG,name+"0s");
                    try {
                        Thread.sleep(1000);
                        Log.e(TAG,name+"1s");
                        Thread.sleep(1000);
                        Log.e(TAG,name+"2s");
                        Thread.sleep(1000);
                        Log.e(TAG,name+"3s");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

        }
    }

它只会用唯一的工作线程来执行任务，可以理解为线程数量为1的FixedThreadPool 。

newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

  private void cacheEcecutor(){
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0 ;i<15;i++){
            final String name = "第"+i+"个线程";
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.e(TAG,name+"0s");
                    try {
                        Thread.sleep(1000);
                        Log.e(TAG,name+"1s");
                        Thread.sleep(1000);
                        Log.e(TAG,name+"2s");
                        Thread.sleep(1000);
                        Log.e(TAG,name+"3s");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

        }
    }

newScheduledThreadPool

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

  private void scheduledEcecutor(){
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        for (int i = 0 ;i<15;i++){
            final String name = "第"+i+"个线程";
//            scheduledThreadPool.schedule(new Runnable() {
//                @Override
//                public void run() {
//                    Log.e(TAG,name+"0s");
//                    try {
//                        Thread.sleep(1000);
//                        Log.e(TAG,name+"1s");
//                        Thread.sleep(1000);
//                        Log.e(TAG,name+"2s");
//                        Thread.sleep(1000);
//                        Log.e(TAG,name+"3s");
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                }
//            }, 4, TimeUnit.SECONDS);
            scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    Log.e(TAG,name+"0s");
                    try {
                        Thread.sleep(1000);
                        Log.e(TAG,name+"1s");
                        Thread.sleep(1000);
                        Log.e(TAG,name+"2s");
                        Thread.sleep(1000);
                        Log.e(TAG,name+"3s");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, 2,4, TimeUnit.SECONDS);

        }
    }

这种方式比较有意思，可以使用 scheduledThreadPool.schedule（），延迟一段时间执行，或者使用 scheduledThreadPool.scheduleAtFixedRate（），像定时器一样的使用，定时执行某个任务。

总结

看完以上介绍，可能仍有人对这些概念有些模糊，最好的办法，其实就是修改几个参数，对比一下log，应该就能明白。
demo下载

Executor与四种线程池