YCBlogs Android 多线程系列:IntentService 完整使用指南与源码深度解析

原创2026-10-09 16:21:521,731 阅读
文章标签:文档技术博客教程知识库

YCBlogs Android 多线程系列:IntentService 完整使用指南与源码深度解析

IntentService 是 Android 官方为开发者提供的"自带工作线程的 Service"基类,用于在后台串行处理异步任务并自动停止。本篇以 android/09.多线程/04.IntentService使用.md 为骨架,结合仓库内 HandlerThread 分析、消息机制流程分析、Looper 深度解析 等笔记,从三步上手实操、日志验证、源码逐段解析到底层 HandlerThread 机制,帮助你彻底掌握 IntentService 的串行执行原理、与 Service 的差异以及实际项目中的适用场景。

01. IntentService 是什么

IntentService 是继承自 Service 的抽象基类,用于处理异步请求。客户端通过 startService() 发送请求后,IntentService 会被启动,并在内部维护的一个工作线程中处理传递过来的 Intent;当所有任务处理完毕,服务会自动停止,无需开发者手动关闭。

它的底层是自己维护了一个线程来执行耗时操作,内部封装了 HandlerThread,从而能够方便地在子线程中创建 Handler,把主线程发来的 Intent 切换到子线程中执行。

1.1 核心作用

  • 开启多线程:服务内部自动创建并维护一个工作线程;
  • 执行异步请求逻辑:把耗时操作从主线程剥离,避免阻塞 UI 线程。

1.2 特性一览

  • IntentService 内部创建了一个工作线程,用于在子线程内执行传递给 onStartCommand() 的所有 Intent,开发者无须关心多线程问题;
  • IntentService 内部通过 HandlerThread + Handler 实现异步操作;
  • IntentService 以串行方式处理外部传递来的任务,即只有当上一个任务完成时,新的任务才会被执行;
  • 在处理完所有任务请求后会自动停止,因此不必手动调用 stopSelf() 方法;
  • 提供了 onBind() 的默认实现(返回 null);
  • IntentService 属于四大组件之一,拥有较高的进程优先级,不易被系统杀死,因此适合执行一些高优先级的异步任务。

02. 三步上手:IntentService 使用步骤

使用 IntentService 只需三个步骤:

  1. 定义 IntentService 的子类:在构造函数中传入线程名称,并复写 onHandleIntent() 方法;
  2. 在 Manifest.xml 中注册服务;
  3. 在 Activity 中开启 Service 服务。

03. 完整实战案例:Application 初始化任务分发

下面以"分担 Application 初始化逻辑"为例,演示完整的三步实现。

3.1 步骤 1:定义 IntentService 子类

创建一个 InitializeService,继承 IntentService。构造函数调用父类构造函数并传入工作线程名字;在 onHandleIntent() 中根据 Action 分发任务(此方法运行在子线程):

/**
 * 初始化工作,子线程,处理耗时操作和避免在 application 做过多初始化工作,
 * 比如初始化数据库等等
 */
@SuppressLint("Registered")
public class InitializeService extends IntentService {

    private static final String ACTION_INIT = "initApplication";

    public static void start(Context context, String name) {
        Intent intent = new Intent(context, InitializeService.class);
        intent.setAction(ACTION_INIT);
        intent.putExtra("name", name);
        context.startService(intent);
    }

    /**
     * 在构造函数中传入线程名字
     */
    public InitializeService() {
        // 调用父类的构造函数
        // 构造函数参数 = 工作线程的名字
        super("InitializeService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        if (intent != null) {
            final String action = intent.getAction();
            String name = intent.getStringExtra("name");
            Log.e("IntentService初始化", "onHandleIntent----" + name);
            if (ACTION_INIT.equals(action)) {
                initApplication();
            }
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.e("IntentService初始化", "onCreate");
    }

    private void initApplication() {
        // 处理耗时操作和避免在 application 做过多初始化工作,比如初始化数据库等等
        Log.e("IntentService初始化", "initApplication");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        Log.e("IntentService初始化", "onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e("IntentService销毁", "onDestroy");
    }
}

说明:onHandleIntent() 是抽象方法,运行在子线程中(源码标注了 @WorkerThread),在这里可以放心执行数据库初始化、网络请求等耗时逻辑;onCreate()、onStartCommand() 仍然运行在主线程,只做轻量操作与日志输出。

3.2 步骤 2:在 Manifest.xml 中注册服务

<service android:name=".InitializeService"/>

3.3 步骤 3:在 Activity 中开启服务

// 同一服务只会开启一个工作线程
// 在 onHandleIntent 函数里依次处理 intent 请求。
InitializeService.start(this, "yc" + i);

04. 日志验证:多次启动与串行执行

连续多次开启服务后,打印日志如下:

2019-05-23 11:57:51.032 20012-20012/cn.ycbjie.ycthreadpool E/IntentService初始化: onCreate
2019-05-23 11:57:51.033 20012-20012/cn.ycbjie.ycthreadpool E/IntentService初始化: onStartCommand
2019-05-23 11:57:51.034 20012-20356/cn.ycbjie.ycthreadpool E/IntentService初始化: onHandleIntent----yc8
2019-05-23 11:57:51.034 20012-20356/cn.ycbjie.ycthreadpool E/IntentService初始化: initApplication
2019-05-23 11:57:51.224 20012-20012/cn.ycbjie.ycthreadpool E/IntentService初始化: onStartCommand
2019-05-23 11:57:51.439 20012-20012/cn.ycbjie.ycthreadpool E/IntentService初始化: onStartCommand
2019-05-23 11:57:53.037 20012-20356/cn.ycbjie.ycthreadpool E/IntentService初始化: onHandleIntent----yc9
2019-05-23 11:57:53.037 20012-20356/cn.ycbjie.ycthreadpool E/IntentService初始化: initApplication
2019-05-23 11:57:55.041 20012-20356/cn.ycbjie.ycthreadpool E/IntentService初始化: onHandleIntent----yc10
2019-05-23 11:57:55.041 20012-20356/cn.ycbjie.ycthreadpool E/IntentService初始化: initApplication
2019-05-23 11:57:57.045 20012-20012/cn.ycbjie.ycthreadpool E/IntentService销毁: onDestroy

日志中有三个非常值得注意的细节:

  1. 线程号的变化:onCreate、onStartCommand 的线程号是 20012(主线程),而 onHandleIntent、initApplication 的线程号是 20356(工作线程),直观印证了任务确实在子线程中执行;
  2. onCreate 只打印了一次:即使连续启动多次,onCreate() 方法也只会调用一次,因此只会创建一个工作线程;
  3. 任务按 2 秒间隔依次执行:yc8 → yc9 → yc10 严格顺序完成,说明多个请求进入了同一个消息队列串行处理。

4.1 多次启动会发生什么

IntentService 多次被启动时,onCreate() 只会调用一次,所以只会创建一个工作线程;但 onStartCommand() 会被调用多次,每次只是把 Intent 包装成 Message 加入消息队列中等待执行。

4.2 为什么任务队列是顺序执行的

结论:如果一个任务正在 IntentService 中执行,此时再发送一个新的任务请求,这个新任务会一直等待,直到前一个任务执行完毕才开始执行。原因有三点:

  1. 由于 onCreate() 方法只会调用一次,所以只会创建一个工作线程;
  2. 当多次调用 startService(Intent) 时(onStartCommand() 也会调用多次),并不会创建新的工作线程,只是把消息加入消息队列中等待执行,所以多次启动 IntentService 会按顺序执行事件;
  3. 如果服务停止,会清除消息队列中的消息,后续的事件得不到执行。

05. IntentService 源码深度解析

下面结合 IntentService 的源码逐段剖析其内部工作机制,重点看它是如何借助 HandlerThread 与 Handler 完成"主线程收请求、子线程串行干活、干完自动停服务"的。

5.1 整体源码展示

public abstract class IntentService extends Service {

    // 子线程中的 Looper
    private volatile Looper mServiceLooper;
    // 内部持有的一个 mServiceHandler 对象
    private volatile ServiceHandler mServiceHandler;
    // 内部创建的线程名字
    private String mName;
    // 服务被异常终止后重新创建调用 onStartCommand 是否回传 Intent
    private boolean mRedelivery;

    /**
     * 内部创建了一个 ServiceHandler,然后将传递过来的 Intent 封装成一个 Message,
     * 再将 Message 解析回 Intent,回调 onHandleIntent。
     * 转换的目的就是将主线程的 Intent 切换到子线程中去执行。
     */
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            // 处理发送过来的消息,在子线程
            onHandleIntent((Intent) msg.obj);
            // 处理完消息之后停止 Service
            stopSelf(msg.arg1);
        }
    }

    /**
     * 工作线程的名字
     */
    public IntentService(String name) {
        super();
        mName = name;
    }

    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        // 创建 HandlerThread
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        // 开启线程,创建子线程 Looper
        thread.start();
        // 获取子线程 Looper
        mServiceLooper = thread.getLooper();
        // 创建子线程 Handler
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        // 创建一个 Message
        Message msg = mServiceHandler.obtainMessage();
        // 消息标志,作为当前 Service 的标志
        msg.arg1 = startId;
        // 携带 Intent
        msg.obj = intent;
        // 发送消息,此时将线程切换到子线程
        mServiceHandler.sendMessage(msg);
    }

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        // 调用 onStart 方法
        onStart(intent, startId);
        // 根据 mRedelivery 的值来确定返回重传 Intent 的黏性广播还是非黏性广播
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        // 退出 Looper
        mServiceLooper.quit();
    }

    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }

    /* 子类必须实现的抽象方法 */
    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

5.2 源码归纳:一条完整的工作链路

从上面源码可以看出,IntentService 本质是采用 Handler + HandlerThread 方式实现的:

  1. 通过 HandlerThread 单独开启一个名为 IntentService[...] 的线程;
  2. 创建一个名叫 ServiceHandler 的内部 Handler;
  3. 把内部 Handler 与 HandlerThread 所对应的子线程进行绑定;
  4. 通过 onStartCommand() 传递给服务的 Intent,依次插入到工作队列中,并逐个发送给 onHandleIntent();
  5. 通过 onHandleIntent() 依次处理所有 Intent 请求对象所对应的任务。

5.3 如何开启 1 个新的工作线程

工作线程的创建发生在 onCreate() 中,这也是"服务只创建一个线程"的根源:

// IntentService 源码中的 onCreate() 方法
@Override
public void onCreate() {
    super.onCreate();
    // HandlerThread 继承自 Thread,内部封装了 Looper
    // 通过实例化 HandlerThread 新建线程并启动
    // 所以使用 IntentService 时不需要额外新建线程
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();

    // 获得工作线程的 Looper,并维护自己的工作队列
    mServiceLooper = thread.getLooper();
    // 将上述获得的 Looper 与新建的 mServiceHandler 进行绑定
    // 新建的 Handler 是属于工作线程的
    mServiceHandler = new ServiceHandler(mServiceLooper);
}

private final class ServiceHandler extends Handler {
    public ServiceHandler(Looper looper) {
        super(looper);
    }

    // IntentService 的 handleMessage 方法把接收的消息交给 onHandleIntent() 处理
    // onHandleIntent() 是一个抽象方法,使用时需要重写的方法
    @Override
    public void handleMessage(Message msg) {
        // onHandleIntent 方法在工作线程中执行,执行完调用 stopSelf() 结束服务
        onHandleIntent((Intent) msg.obj);
        // onHandleIntent 处理完成后 IntentService 会调用 stopSelf() 自动停止
        stopSelf(msg.arg1);
    }
}

// onHandleIntent() 是一个抽象方法,使用时需要重写的方法
@WorkerThread
protected abstract void onHandleIntent(Intent intent);

关键点:ServiceHandler 绑定的 Looper 来自 HandlerThread 的工作线程,因此 handleMessage() 以及它调用的 onHandleIntent() 都运行在子线程;stopSelf(msg.arg1) 中传入的 arg1 是 startId,IntentService 通过"最近一次 startId"判断是否还有未处理完的请求,只有全部处理完毕才真正销毁服务。

5.4 工作任务队列为何是顺序执行的

从 onStartCommand() 与 onStart() 可以看到请求入队的完整过程:

public int onStartCommand(Intent intent, int flags, int startId) {
    onStart(intent, startId);
    return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}

public void onStart(Intent intent, int startId) {
    Message msg = mServiceHandler.obtainMessage();
    msg.arg1 = startId;
    // 把 intent 参数包装到 message 的 obj 中,然后发送消息,即添加到消息队列里
    // 这里的 Intent 就是启动服务时 startService(Intent) 里的 Intent
    msg.obj = intent;
    mServiceHandler.sendMessage(msg);
}

// 清除消息队列中的消息
@Override
public void onDestroy() {
    mServiceLooper.quit();
}

这里的"消息队列"正是 Handler 所依附的 MessageQueue。结合仓库中 消息机制流程分析 与 MessageQueue 解析 的说明:MessageQueue 内部以单链表结构按触发时间顺序存储 Message,Looper 不断从中取出消息交给 Handler 串行处理,因此多次 startService 的请求会严格按照先后顺序执行,不会并发;而 onDestroy() 中调用 mServiceLooper.quit() 会清空消息队列中的消息,这就是"服务停止后,后续事件得不到执行"的原因。

5.5 与 Service 的区别

对比项 Service IntentService
运行线程 依赖于应用程序的主线程(不是独立的进程或线程) 创建一个工作线程来处理多线程任务
耗时操作 不建议编写耗时逻辑,否则会引起 ANR 在 onHandleIntent() 子线程中执行耗时任务
结束方式 需要主动调用 stopSelf() 结束服务 不需要,所有 Intent 处理完后系统自动关闭服务

5.6 与其他线程的区别

  • IntentService 内部采用了 HandlerThread 实现,作用类似于后台线程;
  • 与普通后台线程相比,IntentService 是一种后台服务,优势是优先级高(不容易被系统杀死),从而保证任务的执行。对于后台线程,若进程中没有活动的四大组件,该线程的优先级非常低,容易被系统杀死,无法保证任务的执行。

06. 底层支撑:HandlerThread 深入分析

IntentService 的串行执行能力完全建立在 HandlerThread 之上,因此理解 HandlerThread 是理解 IntentService 的前提。仓库中的 HandlerThread 分析 对其做了详细解读,核心结论如下:

  • HandlerThread 继承于 Thread,本质上就是一个线程类,内部维护了自己的 Looper 对象,可以进行 Looper 循环;
  • 创建 HandlerThread 后需要先调用 start() 方法再向其下发任务,通过 run() 方法来创建 Looper 对象;
  • 通过把 HandlerThread 的 Looper 传给 Handler,就可以通过 Handler 向 HandlerThread 下发耗时任务。

HandlerThread 的 run() 方法与手动创建子线程 Looper 的流程基本一致:

@Override
public void run() {
    mTid = Process.myTid();
    // Looper 准备
    Looper.prepare();
    synchronized (this) {
        mLooper = Looper.myLooper();
        // 唤醒所有等待的线程
        notifyAll();
    }
    // 设置线程优先级
    Process.setThreadPriority(mPriority);
    // 在 Looper 循环时做一些准备工作
    onLooperPrepared();
    // 开启循环
    Looper.loop();
    mTid = -1;
}

几个需要留意的实现细节:

  • getLooper() 的等待机制:由于 getLooper() 可能先于 run() 被调用,源码内部用 synchronized + wait() 阻塞等待 Looper 创建完成(notifyAll() 唤醒),IntentService 正是通过 thread.getLooper() 拿到子线程 Looper 的;
  • quit 与 quitSafely:quit() 直接调用 looper.quit() 清空消息队列;quitSafely() 调用 looper.quitSafely(),只会清空所有延时消息,并派发完剩余的非延时消息,退出更安全。结合 Looper 深度解析 的说明,quitSafely() 从 API Level 18 才加入;
  • 消息处理在子线程:由于 HandlerThread 的本质是线程,与其关联的 Handler 中 handleMessage() 运行在子线程,所以 IntentService 的 onHandleIntent() 也是子线程上下文。

07. 可以通过 bindService 启动 IntentService 吗

不能。看 IntentService 的源码:

@Override
public IBinder onBind(Intent intent) {
    return null;
}

onBind() 默认返回 null。而采用 bindService() 启动 IntentService 时的生命周期是:onCreate() → onBind() → onUnbind() → onDestroy(),不会调用 onStart() 或 onStartCommand(),因此消息不会进入消息队列,onHandleIntent() 也不会被回调,自然无法实现子线程异步操作。这也是 IntentService 只支持 startService() 方式启动的原因。

08. 使用场景与最佳实践

IntentService 不需要我们自己去关闭 Service,它会在任务完成之后自行关闭;不过每次只能处理一个任务,不适用于高并发场景,适用于请求数较少的情况。

8.1 典型适用场景

  1. 顺序执行的纯后台任务:类似 APP 的版本检测更新、后台定位功能以及读取少量的 IO 操作;
  2. 需要按顺序、在后台执行的任务:例如阿里云推送的 Service 就是继承 IntentService 实现的;
  3. 播放音乐、下载文件等:Service 默认运行于 UI 线程,若想依靠其完成耗时任务需要自己建立子线程,比较繁琐,官方提供的 IntentService 恰好解决这一问题;
  4. 分担 Application 初始化逻辑:将部分初始化工作放到 IntentService 中处理,可以提高 Application 启动速度。

8.2 实践案例:Application 初始化瘦身

目前正式项目中 Application 初始化工作太多,可以考虑分担部分逻辑到 IntentService 中处理。例如现在 Application 初始化内容有:数据库初始化、阿里云推送初始化、腾讯 Bugly 初始化、IM 初始化、神策初始化、内存泄漏工具初始化、头条适配方案初始化、阿里云热修复等。将这些逻辑中耗时且不阻塞首屏的部分放到 IntentService 中处理,可以明显缩短 Application 的启动时间。

8.3 在广播接收器中的配合使用

仓库中的 ANR 治理优化实践 也给出了同方向的建议:BroadcastReceiver 的 onReceive() 代码要尽量减少耗时,建议使用 IntentService 处理。因为 onReceive() 运行在主线程,一旦超时会触发 ANR,把耗时逻辑交给 IntentService 既安全又符合"串行后台任务"的定位。

8.4 与其他异步方案的分工

Android 后台异步方案各有侧重,可结合仓库中的 AsyncTask 深入介绍 等笔记做横向对比:

  • Thread / HandlerThread:适合需要长期存在、带 Looper 消息循环的单个工作线程场景;
  • AsyncTask:轻量级异步任务,内部封装了线程池、线程和 Handler,适合短小的后台计算 + UI 更新;
  • IntentService:串行后台任务 + 自动停止,适合"请求少、需保优先级、无需交互"的任务,如初始化、下载、推送处理。

09. 总结

IntentService 是"Service + HandlerThread + Handler"三个组件协同的经典封装:onCreate() 中创建并启动 HandlerThread、绑定子线程 Looper 与 ServiceHandler;onStartCommand() 中把每个 Intent 包装成 Message 入队;ServiceHandler.handleMessage() 在子线程回调 onHandleIntent() 并携带 startId 调用 stopSelf();全部任务完成后服务自动销毁并退出 Looper。开发者唯一需要做的,就是继承它、传一个线程名、重写 onHandleIntent(),然后在 Manifest 中注册、用 startService() 启动即可。

理解它的边界同样重要:任务严格串行、不能 bindService() 启动、服务停止会清空待处理消息,因此它更适合"低并发、高优先级、自动收尾"的后台任务,而不是高并发的任务分发中心。

登录后查看全文
YCBlogs