Android——线程和线程池

主要介绍内容：

Android 中的线程形态
- AsyncTask
- AsyncTask 的工作原理
- HandlerThread
- IntentService
Android 中的线程池
- ThreadPoolExecutor
- 线程池的分类

Android 中的线程形态

这里开始将对线程形态做一个全面的介绍，除了传统的 Thread 以外，还包含 AsyncTask、HandlerThread 以及 IntentService，这三者的底层实现也是线程，但是它们具有特殊的表现形式，同时在使用上也各有优缺点。为了简化在子线程中访问 UI 的过程，系统提供了 AsyncTask，AsyncTask 经过几次的修改，导致了对于不同的 API 版本 AsyncTask 具有不同的表现，尤其是多任务的并发执行上。由于这个原因，很多开发者对 AsyncTask 的使用上存在误区，在这里将详细介绍使用 AsyncTask 时的注意事项，并从源码的角度来分析 AsyncTask 的执行过程。

AsyncTask

AsyncTask 是一种轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终结果传递给主线程并在主线程中更新 UI。从实现上来说，AsyncTask 封装了 Thread 和 Handler，通过 AsyncTask 可以更加方便地执行后台任务以及在主线程中访问 UI，但是 AsyncTask 并不适合进行特别耗时的后台任务，对于特别耗时的任务来说，建议使用线程池。

AsyncTask 是一个抽象的泛型类，它提供了 Params、Progress 和 Result 这三个泛型参数，其中 Params 表示参数的类型，Progress 表示后台任务的执行进度的类型，而 Result 则表示后台任务的返回结果的类型，如果 AsyncTask 确实不需要传递具体的参数，那么这三个泛型参数可以用 Void 来代替。AsyncTask 这个类的声明如下所示：

public abstract class AsyncTask

AsyncTask 提供了 4 个核心方法，它们的含义如下表示：

（1）、onPreExecute()

在主线程中执行，在异步任务执行之前，此方法会被调用，一般可以用于做一些准备工作。

（2）、doInBackground(Params… params)

在线程池中执行，此方法用于执行异步任务， params 参数表示异步任务的输入参数。在此方法中可以通过 publishP rogress(Progress… values) 方法来更新任务的进度， publishProgress(Progress… values) 方法会调用 onProgressUpdate(Progress… values) 方法。另外此方法需要返回计算结果给 onPostExecute 方法。

（3）、onProgressUpdate(Progress… values)

在主线程中执行，当后台任务的执行进度发生变化时此方法会被调用。

（4）、onPostExecute(Result result)

在主线程中执行，在异步任务执行之后，此方法会被调用，其中 result 参数是后台任务的返回值，即 DoInBackground 的返回值。

上面这几个方法，onPreExecute 先执行，接着是 doInBackground，最后才是 onPostExecute。除了上述四个方法以外，AsyncTask 还提供了 onCancelled() 方法，它同样在主线程中执行，当异步任务被取消时，onCallback() 方法会被调用，这个时候 onPostExecute 则不会被调用。下面提供一个典型的示例，如下所示：

    private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {        @Override        protected void onPreExecute() {            // show Lodding            super.onPreExecute();        }        @Override        protected Long doInBackground(URL... params) {            int count = params.length;            long totalSize = 0;            for (int i = 0; i < count; i++) {                totalSize += DownLoader.downloadFile(params[i]);                publishProgress((int) (i / (float) count) * 100);   //获取当前进度百分比                if (isCancelled())                    break;            }            return totalSize;        }        @Override        protected void onProgressUpdate(Integer... values) {            //显示更新的进度            showProgressPercent(values[0]);        }        @Override        protected void onPostExecute(Long aLong) {            //显示返回的结果            showDialog("Downloaded" + aLong + "bytes");        }    };

在上面的代码中，实现了一个具体的 AsyncTask 类，这个类主要用于模拟文件的下载过程，它的输入参数类型为 URL，后台任务的进程参数为 Integer，而后台任务的返回结果为 Long 类型。注意到 DoInBackground 和 onProgressUpdate 方法它们的参数中均包含 … 的字样，在 Java 中 … 表示参数的数量不定，它是一种数组型参数， … 的概念和 C 语言中的 … 是一致的。当要执行上述下载任务时，可以通过如下方式来完成：

new DownloadFilesTask().execute(url1, url2, url3);

在上述的例子中，DoInBackground 用来执行具体的下载任务并通过 publicProgress 方法来更新下载的进度，同时还要判断下载任务是否被外界取消了。当下载任务完成后，DoInBackground 会返回结果，即下载的总字节数。需要注意的是， DoInBackground 是在线程池中执行的。onProgressUpdate 用于更新界面中下载的进度，它运行在主线程中，当 publishProgress 被调用时，此方法就会被调用。当下载任务完成后， onPostExecute 方法就会被调用，它也是运行在主线程中，这个时候我们就可以在界面上做出一些提示，比如弹出一个对话框告知用户下载已经完成。

AsyncTask 在具体的使用过程中也是有一些条件限制的，主要有如下几点：

（1）、AsyncTask 的类必须在主线程中加载，这就意味着访问 AsyncTask 必须发生在主线程，当然这个过程在 Android 4.1 及以上版本中已经被系统自动完成。在 Android 5.0 的源码中，可以查看 ActivityThread 的 main 方法，它会调用 AsyncTask 的 init 方法，这就满足了 AsyncTask 的类必须在主线程中进行加载这个条件了。至于为什么必须要满足这个条件，在接下来对 AsyncTask 的源码分析中会再次分析这个问题。
（2）、AsyncTask 的对象必须在主线程中创建
（3）、execute 方法必须在 UI 线程调用。
（4）、不要在程序中直接调用 onPreExecute()、onPostExecute()、DoInBackground() 和 onProgressUpdate() 方法。
（5）、一个 AsyncTask 对象只能执行一次，即只能调用一次 execute 方法，否则会报运行时异常。
（6）、在 Android 1.6 之前，AsyncTask 是串行执行任务的，Android 1.6 的时候 AsyncTask 开始采用线程池里处理并行任务，但是从 Android 3.0 开始，为了避免 AsyncTask 所带来的并发错误，AsyncTask 又采用一个线程来串行执行任务。尽管如此，在 Android 3.0 以及后续的版本中，我们仍然可以通过 AsyncTask 的 executeOnExecutor 方法来并行地执行任务。

AsyncTask 的工作原理

为了分析 AsyncTask 的工作原理，我们从它的 execute 方法开始分析，execute 方法又会调用 executeOnExecutor 方法，它们的实现如下所示：

    public final AsyncTask execute(Params... params) {        return executeOnExecutor(sDefaultExecutor, params);    }    public final AsyncTask executeOnExecutor(Executor exec,            Params... params) {        if (mStatus != Status.PENDING) {            switch (mStatus) {                case RUNNING:                    throw new IllegalStateException("Cannot execute task:"                            + " the task is already running.");                case FINISHED:                    throw new IllegalStateException("Cannot execute task:"                            + " the task has already been executed "                            + "(a task can be executed only once)");            }        }        mStatus = Status.RUNNING;        onPreExecute();        mWorker.mParams = params;        exec.execute(mFuture);        return this;    }

在上面的代码中，sDefaultExecutor 实际上是一个串行的线程池，一个进程中所有的 AsyncTask 全部在这个串行的线程池中排队执行，这个排队执行的过程后面会在进行详细分析。在 executeOnExecutor 方法中，AsyncTask 的 onPreExecute 方法最先执行，然后线程池开始执行。在看线程池的执行流程之前，我们先看看看 mFuture 是个什么鬼？代码如下所示：

public AsyncTask() {        mWorker = new WorkerRunnable() {            public Result call() throws Exception {                mTaskInvoked.set(true);                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);                //noinspection unchecked                Result result = doInBackground(mParams);                Binder.flushPendingCommands();                return postResult(result);            }        };        mFuture = new FutureTask(mWorker) {            @Override            protected void done() {                try {                    postResultIfNotInvoked(get());                } catch (InterruptedException e) {                    android.util.Log.w(LOG_TAG, e);                } catch (ExecutionException e) {                    throw new RuntimeException("An error occurred while executing doInBackground()",                            e.getCause());                } catch (CancellationException e) {                    postResultIfNotInvoked(null);                }            }        };    }private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {        Params[] mParams;    }

mWorker 其实就是 AsyncTask 的一个内部类，它实现了对 Params 参数的封装，而 mFuture 是一个 FutureTask 对象，FutureTask 是一个并发类，在这里它充当了 Runnable 的作用。

在下面分析线程池的执行过程，如下所示：

private static class SerialExecutor implements Executor {        final ArrayDeque mTasks = new ArrayDeque();        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);            }        }    }

从 SerialExecutor 的实现可以分析 AsyncTask 的排队的过程。首先系统会把封装了 Params 参数的 FutureTask 对象交给 SerialExecutor 的 execute 方法去处理， SerialExecutor 的 execute 方法首先会把 FutureTask 对象插入到任务队列 mTasks 中，如果这个时候没有正在活动的 AsyncTask 任务，那么就会调用 SerialExecutor 的 scheduleNext 方法来执行下一个 AsyncTask 任务。同时当一个 AsyncTask 任务执行完后，AsyncTask 会继续执行其他任务直到所有的任务都被执行为止，从这一点可以看出，在默认情况下，AsyncTask 是串行执行的。

AsyncTask 中有两个线程池（SerialExecutor 和 THREAD_POOL_ECECUTOR）和一个 Handler（InternalHandler），其中线程池 SerialExecutor 用于任务的排列，而线程池 THREAD_POOL_EXECUTOR 用于真正地执行任务（因为 mActive == null) 会调用 scheduleNext() 方法，在 scheduleNext 方法内部会去执行 THREAD_POOL_EXECUTOR 的 execute 方法，从而再去调用 FutureTask 的 run 方法），InternalHandler 用于将执行环境从线程池切换到主线程，关于线程池会在后面详细介绍，其本质仍然是线程的调用过程。在 AsyncTask 的构造方法中有如下这么一段代码，由于 FutureTask 的 run 方法会调用 mWorker 的 call 方法，因此 mWorker 的 call 方法最终会在线程池中执行：

我们先来看一下 AsyncTask 的构造方法：

public AsyncTask() {        mWorker = new WorkerRunnable() {            public Result call() throws Exception {                mTaskInvoked.set(true);                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);                //noinspection unchecked                Result result = doInBackground(mParams);                Binder.flushPendingCommands();                return postResult(result);            }        };        mFuture = new FutureTask(mWorker) {            @Override            protected void done() {                try {                    postResultIfNotInvoked(get());                } catch (InterruptedException e) {                    android.util.Log.w(LOG_TAG, e);                } catch (ExecutionException e) {                    throw new RuntimeException("An error occurred while executing doInBackground()",                            e.getCause());                } catch (CancellationException e) {                    postResultIfNotInvoked(null);                }            }        };    }

在 AsyncTask 的构造方法中，初始化了 mWorker 以及 mFuture，并把 mWorker 作为参数传递给了 FutureTask 的构造函数中，我们来看一下 FutureTask 以及它的 run 方法：

// FutureTask#runpublic class FutureTask implements RunnableFuture public void run() {...Callable c = callable;result = c.call();...    }

代码中的 callable 对象就是我们通过 FutureTask 构造函数传递过来的 mWorker 对象，然后调用了 mWorker 的 call 方法，好了现在回到 mWorker 的 call 方法，看看它究竟做了什么操作：

        mWorker = new WorkerRunnable() {            public Result call() throws Exception {                mTaskInvoked.set(true);                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);                //noinspection unchecked                Result result = doInBackground(mParams);                Binder.flushPendingCommands();                return postResult(result);            }        };

在 mWorker 的 call 方法中，首先将 mTaskInvoked 设为 true，表示当前任务已经被调用过了，然后执行 AsyncTask 的 DoInBackground 方法，接着将其返回值传递给 postResult 方法，它的实现如下所示：

    private Result postResult(Result result) {        @SuppressWarnings("unchecked")        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,                new AsyncTaskResult(this, result));        message.sendToTarget();        return result;    }    private static Handler getHandler() {        synchronized (AsyncTask.class) {            if (sHandler == null) {                sHandler = new InternalHandler();            }            return sHandler;        }    }    private static class AsyncTaskResult {        final AsyncTask mTask;        final Data[] mData;        AsyncTaskResult(AsyncTask task, Data... data) {            mTask = task;            mData = data;        }    }

在上面的代码中，postResult 方法会通过 sHandler 发送一个 MESSAGE_POST_RESULT 的消息，这个 sHandler 的定义如下所示：

private static class InternalHandler extends Handler {        public InternalHandler() {            super(Looper.getMainLooper());        }        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})        @Override        public void handleMessage(Message msg) {            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;            switch (msg.what) {                case MESSAGE_POST_RESULT:                    // There is only one result                    result.mTask.finish(result.mData[0]);                    break;                case MESSAGE_POST_PROGRESS:                    result.mTask.onProgressUpdate(result.mData);                    break;            }        }    }

可以发现，sHandler 是一个静态的 Handler 对象，为了能够将执行环境切换到主线程，这就要求 sHandler 这个对象必须在主线程中创建。由于静态成员会在加载类的时候进行初始化，因此这就变相地要求 AsyncTask 的类必须在主线程中加载，否则同一个进程中的 AsyncTask 都无法正常工作。 sHandler 收到 MESSAGE_POST_RESULT 这个消息后，会调用 AsyncTask 的 finish 方法，如下所示：

    private void finish(Result result) {        if (isCancelled()) {            onCancelled(result);        } else {            onPostExecute(result);        }        mStatus = Status.FINISHED;    }

AsyncTask 的 finish 方法的逻辑比较简单，如果 AsyncTask 被取消执行了，那么就调用 onCancelled 方法，否则就会调用 onPostExecute 方法，可以看到 DoInBackground 的返回结果会传递给 onPostExecute 方法，到这里 AsyncTask 的整个工作过程就分析完毕了。

通过分析 AsyncTask 的源码，可以进一步确定，从 Android 3.0 开始，默认情况下 AsyncTask 的确是串行执行的，在这里通过一系列实验来证实这个判断。

请看如下实现代码，代码很简单，就是单击按钮的时候同时执行 5 个 AsyncTask 任务，每个 AsyncTask 会休眠 3s 来模拟耗时任务，同时把每个 AsyncTask 任务结束的时候打印出来，这样我们就能观察出 AsyncTask 到底是串行执行还是并行执行。

    private class DownloadFilesTask extends AsyncTask {        private String mName = "DownloadFilesTask";        public DownloadFilesTask(String name) {            super();            mName = name;        }        @Override        protected void onPreExecute() {            // show Lodding            super.onPreExecute();        }        @Override        protected String doInBackground(String... params) {            try {                Thread.sleep(3000);            } catch (InterruptedException e) {                e.printStackTrace();            }            return mName;        }        @Override        protected void onProgressUpdate(Integer... values) {            //显示更新的进度        }        @Override        protected void onPostExecute(String result) {            //显示返回的结果            super.onPostExecute(result);            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");            Log.e("DownloadFilesTask", result + "execute finish at " + df.format(new Date()));        }    }

分别在 Android 3.2.0 和 Android 2.3.3 的设备上运行程序，按照咱们前面的描述，Android 在 3.2.0 上应该是串行的，在 2.3.3 上应该是并行的，到底是不是这样呢？请看下面的运行结果：

Android 3.2.0 上执行：如下所示：5 个 AsyncTask 共耗时 15s 且时间间隔为 3s 很显然是串行执行的。

10-15 16:14:15.874 7636-7636/? E/DownloadFilesTask: DownloadFilesTask#1execute finish at 2016-10-15 16:14:1510-15 16:14:18.905 7636-7636/? E/DownloadFilesTask: DownloadFilesTask#2execute finish at 2016-10-15 16:14:1810-15 16:14:21.947 7636-7636/? E/DownloadFilesTask: DownloadFilesTask#3execute finish at 2016-10-15 16:14:2110-15 16:14:24.981 7636-7636/? E/DownloadFilesTask: DownloadFilesTask#4execute finish at 2016-10-15 16:14:2410-15 16:14:28.025 7636-7636/? E/DownloadFilesTask: DownloadFilesTask#5execute finish at 2016-10-15 16:14:28

Android 2.3.3 上执行，如下所示：5 个 AsyncTask 的结束时间是一样的，很显然是并行执行的。

10-15 16:16:09.077 8108-8108/? E/DownloadFilesTask: DownloadFilesTask#3execute finish at 2016-10-15 16:16:0910-15 16:16:09.080 8108-8108/? E/DownloadFilesTask: DownloadFilesTask#2execute finish at 2016-10-15 16:16:0910-15 16:16:09.083 8108-8108/? E/DownloadFilesTask: DownloadFilesTask#4execute finish at 2016-10-15 16:16:0910-15 16:16:09.085 8108-8108/? E/DownloadFilesTask: DownloadFilesTask#5execute finish at 2016-10-15 16:16:0910-15 16:16:09.087 8108-8108/? E/DownloadFilesTask: DownloadFilesTask#1execute finish at 2016-10-15 16:16:09

为了让 AsyncTask 可以在 Android 3.0 及以上版本上并行，可以采用 AsyncTask 的 executeOnExecutor 方法，需啊哟注意的是这个方法是 Android 3.0 新添加的方法，并不能在低版本上使用，如下所示：

        bt_.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View v) {                new DownloadFilesTask("DownloadFilesTask#1").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");                new DownloadFilesTask("DownloadFilesTask#2").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");                new DownloadFilesTask("DownloadFilesTask#3").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");                new DownloadFilesTask("DownloadFilesTask#4").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");                new DownloadFilesTask("DownloadFilesTask#5").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");            }        });

在 Android 3.2.0 的设备上运行上述程序，很显然，我们的目的达到了，成功地让 AsyncTask 在 3.2.0 的手机上并行起来了

10-15 16:20:27.823 8591-8591/? E/DownloadFilesTask: DownloadFilesTask#1execute finish at 2016-10-15 16:20:2710-15 16:20:27.824 8591-8591/? E/DownloadFilesTask: DownloadFilesTask#3execute finish at 2016-10-15 16:20:2710-15 16:20:27.825 8591-8591/? E/DownloadFilesTask: DownloadFilesTask#2execute finish at 2016-10-15 16:20:2710-15 16:20:27.826 8591-8591/? E/DownloadFilesTask: DownloadFilesTask#4execute finish at 2016-10-15 16:20:2710-15 16:20:27.827 8591-8591/? E/DownloadFilesTask: DownloadFilesTask#5execute finish at 2016-10-15 16:20:27

HandlerThread

HandlerThread 继承了 Thread，它是一种可以使用 Handler 的 Thread，它的实现也很简单，就是在 run 方法中通过 Looper.prepare() 来创建消息队列，并通过 Looper.loop() 来开启消息循环，这样在实际的使用就允许在 HandlerThread 中创建 Handler 了。HandlerThread 的 run 方法如下所示：

    @Override    public void run() {        mTid = Process.myTid();        Looper.prepare();        synchronized (this) {            mLooper = Looper.myLooper();            notifyAll();        }        Process.setThreadPriority(mPriority);        onLooperPrepared();        Looper.loop();        mTid = -1;    }

从 HandlerThread 的实现来看，它和普通的 Thread 有显著的不同之处。普通 Thread 主要用于在 run 方法中执行一个耗时任务，而 HandlerThread 在内部创建了消息队列，外界需要通过 Handler 的消息方式来通知 HandlerThread 执行一个具体的任务。HandlerThread 是一个很有用的类，它在 Android 中的一个具体的使用场景是 IntentService，IntentService 将在下面进行介绍。由于 HandlerThread 的 run 方法是一个无限循环，因此当明确不需要再使用 HandlerThread 时，可以通过它的 quit 或者 quitSafely 方法来终止线程的执行，这是一个良好的编程习惯。

IntentService

IntentService 是一种特殊的 Service，它继承了 Service 并且它是一个抽象类，因此必须创建它的子类才能使用 IntentService。IntentService 可用于执行后台耗时任务，当任务执行后它会自动停止，同时由于 IntentService 是服务的原因，这导致它的优先级比单纯的线程要高很多，所以 IntentService 比较合适执行一些高优先级的后台任务，因为它优先级高不容易被系统杀死。在实现上，IntentService 封装了 HandlerThread 和 Handler，这一点可以从它的 onCreate 方法中看出来，如下所示：

    @Override    public void onCreate() {        // TODO: It would be nice to have an option to hold a partial wakelock        // during processing, and to have a static startService(Context, Intent)        // method that would launch the service & hand off a wakelock.        super.onCreate();        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");        thread.start();        mServiceLooper = thread.getLooper();        mServiceHandler = new ServiceHandler(mServiceLooper);    }    private final class ServiceHandler extends Handler {        public ServiceHandler(Looper looper) {            super(looper);        }        @Override        public void handleMessage(Message msg) {            onHandleIntent((Intent)msg.obj);            stopSelf(msg.arg1);        }    }

当 IntentService 被第一次启动时，它的 onCreate 方法会被调用，onCreate 方法会创建一个 HandlerThread，然后使用它的 Looper 来够着一个 Handler 对象 mServiceHandler，这样通过 mServiceHandler 发送的消息最终都会在 HandlerThread 中执行，从这个角度来看，IntentService 也可以用于执行后台任务。每次启动 IntentService，它的 onStartCommand 方法就会被调用一次，IntentService 在 onStartCommand 中处理每个后台任务的 Intent。下面看一下 onStartCommand 方法是如何处理外界的 Intent 的，onStartCommand 调用了 onStart，onStart 方法的实现如下所示：

    @Override    public void onStart(Intent intent, int startId) {        Message msg = mServiceHandler.obtainMessage();        msg.arg1 = startId;        msg.obj = intent;        mServiceHandler.sendMessage(msg);    }

可以看出，IntentService 仅仅是通过 mServiceHandler 发送了一个消息，这个消息会在 HandlerThread 中被处理。mServiceHandler 收到消息后，会将 Intent 对象传递给 onHandlerIntent 方法去处理。注意这个 Intent 对象的内容和外界的 startService(intent) 中的 intent 的内容是完全一致的，通过这个 Intent 对象即可解析出外界启动 IntentService 时所传递的参数，通过这些参数就可以区分具体的后台任务，这样在 onHandlerIntent 方法中就可以对不同的后台任务做处理了。当 onHandlerIntent 方法执行结束后，IntentService 会通过调用 stopSelf(int startId) 方法来尝试停止服务。这里之所以采用 stopSelf(int startId) 而不是 stopSelf() 来停止服务，那是因为 stopSelf() 会立刻停止服务，而这个时候可能还有其他消息为处理，stopSelf(int startId) 则会等待所有的消息都处理完毕后才终止服务。一般来说，stopSelf(int startId) 在尝试停止服务之前会判断最近启动服务的次数是否和 startId 相等，如果相等就立即停止服务，不相等则不停止服务，这个策略可以从 AMS 的 stopServiceToken 方法的实现中找到依据，大家感兴趣的话可以自行查看源码实现。ServiceHandler 的实现如下所示：

    private final class ServiceHandler extends Handler {        public ServiceHandler(Looper looper) {            super(looper);        }        @Override        public void handleMessage(Message msg) {            onHandleIntent((Intent)msg.obj);            stopSelf(msg.arg1);        }    }

IntentService 的 onHandlerIntent 方法是一个抽象方法，它需要我们在子类中实现，它的作用是从 Intent 参数中区分具体的任务并执行这些任务。如果目前只存在一个后台任务，那么 onHandlerIntent 方法执行完这个任务后，stopSelf(int startId) 就会直接停止服务；如果目前存在多个后台任务，那么当 onHandlerIntent 方法执行完最后一个任务时，stopSelf(int startId) 才会直接停止服务。另外，由于每执行一个后台任务就必须情动一个 IntentService，而 IntentService 内部则通过消息的方式向 HandlerThread 请求执行任务，Handler 中的 Looper 是顺序处理消息的，这就意味着 IntentService 也是顺序执行后台任务的，当有多个后台任务同时存在是，这些后台任务会按照外界发起的顺序排队执行。

下面通过一个示例来进一步说明 IntentService 的工作方式，首先派生一个 IntentService 的子类，比如 LocalIntentService，它的实现如下所示：

    public class LocalIntentService extends IntentService {        /**         * Creates an IntentService.  Invoked by your subclass's constructor.         *         * @param name Used to name the worker thread, important only for debugging.         */        public LocalIntentService(String name) {            super(name);        }        @Override        protected void onHandleIntent(Intent intent) {            String action = intent.getStringExtra("task_action");            Log.e("LocalIntentService", "receive task:" + action);            SystemClock.sleep(3000);            if ("com.mk.action.TASK1".equals(action)) {                Log.e("LocalIntentService", "handler task:" + action);            }        }        @Override        public void onDestroy() {            Log.e("LocalIntentService", "service destroy");            super.onDestroy();        }    }

这里对 LocalIntentService 的实现做一下简单的说明。在 onHandlerIntent 方法中会从参数中解析出后台任务的标识，即 task_action 字段所代表的内容，然后根据不同的任务标识来执行具体的后台任务。这里为了简单起见，直接通过 SystemClock.sleep(3000) 来休眠 3000 毫秒从而模拟一种耗时的后台任务，另外为了验证 IntentService 的停止时机，这里在 onDestory 中打印了一句日志。 LocalIntentService 实现完成了以后，就可以在外界请求执行后台任务了，在下面的代码中发起了 3 个后台任务的请求：

        Intent service = new Intent(this, LocalIntentService.class);        service.putExtra("task_action", "com.mk.action.TASK1");        startService(service);        service.putExtra("task_action", "com.mk.action.TASK2");        startService(service);        service.putExtra("task_action", "com.mk.action.TASK3");        startService(service);

运行程序，观察日志，如下显示：

10-15 21:57:00.089 17989-17989/? E/LocalIntentService: receive task:com.mk.action.TASK110-15 21:57:00.091 17989-17989/? E/LocalIntentService: handler task:com.mk.action.TASK110-15 21:57:00.093 17989-17989/? E/LocalIntentService: receive task:com.mk.action.TASK210-15 21:57:00.095 17989-17989/? E/LocalIntentService: receive task:com.mk.action.TASK310-15 21:57:00.096 17989-17989/? E/LocalIntentService: service destroy

从上面的日志可以看出，三个后台任务是排队执行的，它们的执行顺序就是它们发起请求的顺序，即 TASK1、TASK2、TASK3.另外一点就是当 TASK3 执行完毕后，LocalIntentService 才真正地停止，从日志中可以看出 LocalIntentService 执行了 onDestory()，这也意味着服务正在停止。

Android 中的线程池

提到线程池就必须先说下线程池的好处，相信大家都有所体会，线程池的优点可以概括为一下三点：

（1）重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。
（2）能有效控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象。
（3）能对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能。

Android 中的线程池的概念来源于 Java 中的 Executor，Executor是一个接口，真正的线程池的实现为 ThreadPoolExecutor。ThreadPoolExecutor 提供了一系列参数来配置线程池，通过不同的参数可以创建不同的线程池，从线程池的功能特性上来说，Android 的线程池主要分为 4 类，这 4 类线程池可以通过 Executors 所提供的工厂方法来得到，具体会在 “线程池的分类”中进行详细介绍。由于 Android 中的线程池都是直接或者间接通过配置 ThreadPoolExecutor 来实现的，因此在介绍它们之前需要先介绍 ThreadPoolExecutor。

ThreadPoolExecutor

ThreadPoolExecutor 是线程池的真正实现，它的构造方法提供了一系列参数来配置线程池，下面介绍 ThreadPoolExecutor 的构造方法中各个参数的含义，这些参数将直接影响到线程池的功能特性，下面是 ThreadPoolExecutor 的一个比较常用的构造方法。

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

corePoolSize

线程池的核心线程数，默认情况下，核心线程会在线程池中一直存活，即使它们处于闲置状态。如果将 ThreadPoolExecutor 的 allowCoreThreadTimeOut 属性设置为 true，那么闲置的核心线程在等待新任务到来时会有超时策略，这个时间间隔由 keepAliveTime 所指定，当等待时间超过 keepAliveTime 所指定的时长后，核心线程就会被终止。

maximumPoolSize

线程池所能容纳的最大线程数，当活动线程数到这个数值后，后续的新任务将会被阻塞。

keepAliveTime

非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收。当 ThreadPoolExecutor 的 allowCoreThreadTimeOut 属性设置为 true时，keepAliveTime 同样会作用域核心线程。

unit

用于指定 keepAliveTime 参数的时间单位，这是一个枚举，常用的有 TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）以及 TimeUnit.MIUNTES（分钟）等。

workQueue

线程池中的任务队列，通过线程池的 execute 方法提交的 Runnable 对象会存储在这个参数中。

threadFactory

线程工厂，为线程池提供创建新线程的功能。ThreadFactory 是一个接口，它只有一个方法：Thread newThread(Runnable r)

除了上面的这些主要参数以外，ThreadPoolExecutor 还有一个不常用的参数 RejectedExecutionHandler handler。当线程池无法执行新任务时，这可能是由于任务队列已满或者是无法成功执行任务，这个时候 ThreadPoolExecutor 会调用 handler 的 rejectedExecution(Runnable r, ThreadPoolExecutor executor) 方法来通知调用者，默认情况下 rejectedExecution 方法会直接抛出一个 RejectedExecutionException。ThreadPoolExecutor 为 RejectedExecutionHandler 提供了几个可选值：CallerRunsPolicy、AbortPolicy、DiscardPolicy 和 DiscardOldestPolicy，其中 AbortPolicy 是默认值，它会直接抛出 RejectedExecutionException，由于 handler 这个参数不常用，这里就不再具体介绍了。

ThreadPoolExecutor 执行任务时大致遵循如下规则：

（1）如果线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行任务。
（2）如果线程池中的线程数量已经达到或者超过核心线程的数量，那么任务会被插入到任务队列中排队等待执行。
（3）如果在步骤 2 中无法将任务插入到任务队列中，这往往是由于任务队列已满，这个时候如果线程数量未达到线程池规定的最大值，那么会立即启动一个非核心线程来执行任务。
（4）如果步骤 3 中线程数量已经达到线程池规定的最大值，那么就拒绝执行此任务，ThreadPoolExecutor 会调用 RejectedExecutionHandler 的 rejectedExecution 方法来通知调用者。

ThreadPoolExecutor 的参数配置在 AsyncTask 中有明显的体现，下面是 AsyncTask 中的线程池的配置情况：

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;    private static final int KEEP_ALIVE = 1;    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 sPoolWorkQueue =            new LinkedBlockingQueue(128);    /**     * An {@link Executor} that can be used to execute tasks in parallel.     */    public static final Executor THREAD_POOL_EXECUTOR            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

从上面的代码可以知道，AsyncTask 对 THREAD_POOL_EXECUTOR 这个线程池进行了配置，配置后的线程池规格如下：

核心线程数等于 CPU 核心数 + 1；
线程池的最大线程数为 CPU 核心数的 2 倍 + 1；
核心线程无超时机制，非核心线程在闲置时的超时时间为 1 秒；
任务队列的容量为 128；

线程词的分类

上面我们已经对 ThreadPoolExecutor 的配置进行了详细的介绍，在这里我们将接着介绍 Android 中最常见的四类具有不同功能特性的线程池，它们都直接或间接地通过配置 ThreadPoolExecutor 来实现自己的功能特性，这四类线程池分别是 FixedThreadPool、CacheThreadPool、ScheduledThreadPool 以及 SingleThreadExecutor。

1、FixedThreadPool

通过 Executors 的 newFixedThreadPool 方法来创建。它是一种线程数量固定的线程池，当线程处于空闲状态时，它们并不会被回收，除非线程池被关闭了。当所有的线程都处于活动状态时，新任务都会处于等待状态，直到有线程空闲出来。由于 FixedThreadPool 只有核心线程并且这些核心线程不会被回收，这意味着它能够更加快速地响应外界的请求， newFixedThreadPool 方法的实现如下，可以发现 FixedThreadPool 中只有核心线程并且这些核心线程没有超时机制，另外任务队列也是没有大小限制的。

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

2、CacheThreadPool

通过 Executors 的 newCachedThreadPool 方法来创建。它是一种线程数量不定的线程池，它只有非核心线程，并且其最大线程数为 Integer.MAX_VALUE。由于 Integer.MAX_VALUE 是一个很大的数，是加上就相当于最大线程数可以任意大。当线程池中的线程都处于活动状态时，线程池会创建新的线程来处理新任务，否则就会利用空闲的线程来处理新任务。线程池中的空闲线程都有超时机制，这个超时时长为 60秒，超过 60秒闲置线程就会被回收。和 FixedThreadPool 不同的是， CachedThreadPool 的任务队列其实相当于一个空集合，这将导致任何任务都会立即被执行，因为在这种场景下 SynchronousQueue 是无法插入任务的。 SynchronousQueue 是一个非常特殊的队列，在很多情况下可以把他简单理解为一个无法存储元素的队列，由于它在实际中较少使用，这里就不在深入探讨它了。从 CachedThreadPool 的特性来看，这类线程池比较适合执行大量的耗时较少的任务。当整个线程池都处于闲置状态时，线程池中的线程都会超时而被停止，这个时候 CachedThreadPool 之中实际上是没有任何线程的，它几乎是不占用任何系统资源的。newCachedThreadPool 方法的实现如下所示：

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

3、ScheduledThreadPool

通过 Executors 的 newScheduledThreadPool 方法来创建。它的核心线程数量是固定的，而非核心线程数是没有现在的，并且当非核心线程闲置时会被立即回收。ScheduledThreadPool 这类线程池主要用于执行定时任务和具有固定周期的重复任务，newScheduledThreadPool 方法的实现如下所示：

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {        return new ScheduledThreadPoolExecutor(corePoolSize);    }    public ScheduledThreadPoolExecutor(int corePoolSize,                                       ThreadFactory threadFactory) {        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,              new DelayedWorkQueue(), threadFactory);    }public class ScheduledThreadPoolExecutor        extends ThreadPoolExecutor        implements ScheduledExecutorService

4、SingleThreadExecutor

通过 Executors 的 newSingleThreadExecutor 方法来创建。这类线程池内部只有一个核心线程池，它确保所有的任务都在同一个线程中按顺序执行。SingleThreadExecutor 的意义在于统一所有的外界任务到一个线程中，这使得在这些任务之间不需要处理线程同步的问题。newSingleThreadExecutor 方法的实现如下所示：

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

上面对 Android 中常见的 4 种线程池进行了详细的介绍，除了上面系统提供的 4 类线程池以外，也可以根据实际需要灵活地配置线程池。下面的代码演示了系统预置的 4 类线程池的典型使用方法。

    private void showThreadPoolExecutor() {        Runnable command = new Runnable() {            @Override            public void run() {                Log.e("========","执行了......");            }        };        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);        fixedThreadPool.execute(command);        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();        cachedThreadPool.execute(command);        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);        //2000ms后执行 command        scheduledThreadPool.schedule(command, 2000, TimeUnit.MILLISECONDS);        //延迟 10ms 后，每隔 1000ms 执行一次 command        scheduledThreadPool.scheduleAtFixedRate(command, 10, 1000, TimeUnit.MILLISECONDS);        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();        singleThreadExecutor.execute(command);    }