上篇博文我們一起查看了AsyncTask的执行流程，但是由于篇幅的原因，我们没有对AsyncTask的默认启动方式(sDefaultExecutor)进行解析。那么，这篇博文我们对sDefaultExecutor进行解析。

 

相关博文

Android基础-AsyncTask基本使用

源码解析-AsyncTask源码解析

---

我们先回顾一下在上篇博文中的内容，再启动AsyncTask的时候我们可以用两个方法。一个是调用execute方法，一个是调用executeOnExecutor方法,execute方法最后是调用executeOnExecutor方法，而他传的参数中就有一个sDefaultExecutor，这个就是我们重点研究的对象。

先贴一下源码

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }


    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

我把一些不想关的代码去掉之后，这里的结构就很清晰了。

首先在execute方法中，把sDefaultExecutor作为执行AsyncTask的执行线程池传了进去，而这个sDefaultExecutor是AsyncTask的一个静态私有且具有部分线程安全的一个线程池，他的真正的实现是下面代码

 private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

我们说过这个线程池是静态的，而在AsyncTask中它也没有被二创建，那么就代表他只有独一份的，所以所有用AsyncTask使用的也是同一个对象。

我们先看一下这个内部类的结构，首先他有两个成员变量，mTasks 的类型是一个队列，队列存储的是Runable，mActive的类型是Runable。在调用这个方法的时候首先会调用的这个类excute方法，这个方法向mtask中添加了一个Runable，这个时候我们就知道mTask是一个把各个AsyncTask执行的runable按照顺序排列的容器。添加完了之后查看了一下mActive是否为null，然后如果为null，则执行scheduleNext方法。看到这里我们还是不明白mActive是什么意思，我们看一下scheduleNext方法里面做了什么。

首先scheduleNext从mTask中获取一个runable，并将去赋值给mActivie(这个时候我们就可以知道这个mActive就是当前执行Runable)，然后检查他是否为null，不为null的时候就用 THREAD_POOL_EXECUTOR 去处理这个runable。

然后我们返回去看一下在添加到mTask中还做了什么吧。这里重新创建了一个新的Runable去执行我们闯入的Runable，然后他用finally包裹了scheduleNext方法，finally这个关键词我们很清楚，无论try里面怎么样他都会被调用。那这里代表什么意思呢，我们想一下这个他的这个意思，一个执行完了之后调用scheduleNext重新赋值mActivie，然后让他执行，这不就是保证了AsyncTask在同一个时间内只会有事件被执行，等当前的这个线程被执行完了之后，下个待处理的事件才会被执行。

到这里我们就可以知道其实这个 SerialExecutor 按照最近流行的说法来说，他就是个打工仔，把所有的后台执行的线程保存到他的成员变量里面，然后按照顺序把线程传递给另一个线程池来执行。分析到这里，我们已经把sDefaultExecutor分析完了，接下来我们来简单看一下另外的一个线程池是什么样子的。

   private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
   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);

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

咋一眼看好像挺多挺复杂的，其实这里只是个普通的自定的自定义线程池，大部分的代码都是线程池的初始化参数(大家在自定义线程池的时候可以参照这里来)。从初始化的参数来，这个线程池虽然支持多个线程并行操作，但是由于之前的sDefaultExecutor每一次只给他一个runable，所以我们从外面来看AsyncTask每一次还是只能执行一个任务。

到这里，基本上AsyncTask都已经讲解完了，下一篇博文将会对AsyncTask进行一次问题汇总及解答。