IntentService 介绍和源码分析

IntentService 是系统提供的一种 Service，它用 Intent 传递数据，用子线程执行代码。使用时需要继承 IntentService，自定义 Intent 中携带的数据格式以及对应的执行代码，外部调用时需要按照格式定义 Intent 数据并启动服务。

什么时候用

Service 作为四大组件之一，用来实现与 UI 无关的功能，但 Service 各个生命周期的方法仍然运行在 UI 线程中，这就需要将任务提交到子线程中执行一些耗时任务。IntentService 就是安卓系统提供的一种使用子线程执行任务的 Service。

IntentService 将任务提交到一个 worker 线程中，使用者只需要定义好 Intent 数据格式，实现解析 Intent 和执行任务的代码即可，使用起来非常简单。同时 IntentService 保证多个任务在 worker 线程中按提交顺序串行执行。这个 worker 线程不会一直存在，一旦任务执行完毕，IntentService 就会自行销毁。

因此，IntentService

适合：

• 需要串行运行的任务
• 轻量级耗时任务，不能在 UI 线程执行，但多个任务顺序执行不会阻塞

不适合：

• 需要并行运行的任务，比如下载多个文件
• 需要一直运行的任务，比如监听网络请求
• 非常耗时的任务，会阻塞后面提交的任务

使用步骤

1. 定义一个 Service 继承自 IntentService。

public class MyIntentService extends IntentService {
}

2. 定义数据格式，将其封装在 Intent 中。

public static void startSave(Context context, String data, String name, int count) {
    Intent intent = new Intent(context, MyIntentService.class);
    intent.putExtra("data", data);
    intent.putExtra("name", name);
    intent.putExtra("count", count);
    context.startService(intent);
}

3. 实现 protected void onHandleIntent(Intent intent) 方法
   1. 解析 Intent 中的参数
   2. 根据参数执行任务

@Override
protected void onHandleIntent(@Nullable Intent intent) {
    int function = intent.getIntExtra("function", 0);
    switch (function) {
        case FUNCTION_SAVE:
            String data = intent.getStringExtra("data");
            String name = intent.getStringExtra("name");
            int count = intent.getIntExtra("count", 0);
            doFunction(data, name, count);
            break;
    }
}

4. 在需要执行任务的地方，启动服务

MyIntentService.startSave(this, "569585687455236541789355", "image", 1);

源码分析

HandlerThread

在分析 IntentService 的源码之前，先简单介绍一下 HandlerThread，因为这是 IntentService 的核心。

从名字可以看出来 HandlerThread 是一个线程，一个带 Handler 的线程，可以通过 Handler 发送消息与线程通信。它的源码也非常简单，去掉注释不到一百行，下面简单分析一下 run() 方法和 getLooper() 方法。

下面是 run() 方法和 getLooper() 方法的简化版源码，删除了一些不太重要的代码。

public void run() {
    Looper.prepare(); // Looper 使用第一步 prepare()
    synchronized (this) { // 这里锁一下，保护 mLooper 变量。
        mLooper = Looper.myLooper(); // 获得 Looper 引用
        notifyAll();
    }
    Looper.loop(); // Looper 使用最后一步，开始无限消息循环
}

public Looper getLooper() {
    // 线程 alive 状态才有意义，所以必须先调用线程的 start()，再调用这个方法。
    if (!isAlive()) {
        return null;
    }
    // 这里的 synchronized 锁对应 run() 方法中的 synchronized 锁。
    // run() 方法中对 mLooper 的初始化代码运行在这个 HandlerThread 中，而 getLooper() 方法读取 
    // mLooper 变量运行在另一个线程中。没错，这就是一个简单的生产者/消费者的场景。
    synchronized (this) {
        // 判断 alive 考虑 while 循环运行过程中线程中止的情况。
        while (isAlive() && mLooper == null) { // 循环套 wait() ，下面详细解释。
            try {
                wait(); // 等待 mLooper 初始化完成后的 notify
            } catch (InterruptedException e) {
            }
        }
    }
    return mLooper;
}

循环套 wait() 的写法，是并发代码的标准套路。

• wait() 是为了等待一个条件是否满足，这里是等待 mLooper 可用。但触发 wait() 继续执行的 notify() 却并不一定是因为准备好了 mLooper 才执行的。wait() 继续执行了不代表条件就满足了，因此要循环重复判断条件才能确保条件是真的满足了。
• wait() 还可能抛出 InterruptedException，例如被 Thread.interrupt() 中断，这时等待的条件不一定被满足，需要重复检查。

可以看 Java 官方文档有详细的解释，讲得非常好：Guarded Blocks

IntentService.onCreat()

初始化 worker 线程，也就是 HandlerThread。可见 IntentService 的核心是通过 Handler 消息机制来与 worker 线程通信。这几句代码也是 HandlerThread 的一个典型使用步骤。

@Override
public void onCreate() {
    super.onCreate();
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper); // 自定义 Handler 处理消息
}

IntentService.onStart()

每次启动服务就是一次任务提交，任务自定义的数据和参数都封装在了 Intent 对象中，这个 Intent 对象被封装到了 Message 对象中，传递给 worker 线程。

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

注意还有个 startId 也保存到了 Message 中，这是用来自动停止服务用的，可以参考上一篇文章有详细说明 startId 如何用来停止 Service：Android - Service Start/Stop 使用

ServiceHandler

HandlerThread 的 Handler，handleMessage() 方法在 worker 线程中执行。调用 IntentService 子类的抽象方法 onHandleIntent() 来自定义业务逻辑。

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

运行完成之后，执行 stopSelf(startId) 结束本次任务，注意是本次任务而不是整个服务。参数 startId 的意义就在于它代表了一次任务的提交，使 stopSelf 方法不会直接停止服务，而是停止一个任务。内部实现是用最后一个 startId 来判断的，只有这个 startId 是最后一个通过 onStartCommand 传递来的 startId，stopSelf(startId) 才会停止任务，否则忽略。

IntentService 自动停止和串行的原理

• 因为 stopSelf(startId) 保证所有提交的任务处理完成后才停止服务，使得 IntentService 在提交任务速度大于任务处理速度的时候，能保持服务持续运行，不会重复创建多个服务浪费资源。
• 得益于 Handler 消息可以串行处理，IntentService 处理任务是串行执行在 worker 线程中的。