YCBlogs Android 多线程系列:IntentService 完整使用指南与源码深度解析
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 只需三个步骤:
- 定义 IntentService 的子类:在构造函数中传入线程名称,并复写
onHandleIntent()方法; - 在 Manifest.xml 中注册服务;
- 在 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
日志中有三个非常值得注意的细节:
- 线程号的变化:
onCreate、onStartCommand的线程号是20012(主线程),而onHandleIntent、initApplication的线程号是20356(工作线程),直观印证了任务确实在子线程中执行; - onCreate 只打印了一次:即使连续启动多次,
onCreate()方法也只会调用一次,因此只会创建一个工作线程; - 任务按 2 秒间隔依次执行:
yc8 → yc9 → yc10严格顺序完成,说明多个请求进入了同一个消息队列串行处理。
4.1 多次启动会发生什么
IntentService 多次被启动时,onCreate() 只会调用一次,所以只会创建一个工作线程;但 onStartCommand() 会被调用多次,每次只是把 Intent 包装成 Message 加入消息队列中等待执行。
4.2 为什么任务队列是顺序执行的
结论:如果一个任务正在 IntentService 中执行,此时再发送一个新的任务请求,这个新任务会一直等待,直到前一个任务执行完毕才开始执行。原因有三点:
- 由于
onCreate()方法只会调用一次,所以只会创建一个工作线程; - 当多次调用
startService(Intent)时(onStartCommand()也会调用多次),并不会创建新的工作线程,只是把消息加入消息队列中等待执行,所以多次启动 IntentService 会按顺序执行事件; - 如果服务停止,会清除消息队列中的消息,后续的事件得不到执行。
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 方式实现的:
- 通过 HandlerThread 单独开启一个名为
IntentService[...]的线程; - 创建一个名叫
ServiceHandler的内部 Handler; - 把内部 Handler 与 HandlerThread 所对应的子线程进行绑定;
- 通过
onStartCommand()传递给服务的 Intent,依次插入到工作队列中,并逐个发送给onHandleIntent(); - 通过
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 典型适用场景
- 顺序执行的纯后台任务:类似 APP 的版本检测更新、后台定位功能以及读取少量的 IO 操作;
- 需要按顺序、在后台执行的任务:例如阿里云推送的 Service 就是继承 IntentService 实现的;
- 播放音乐、下载文件等:Service 默认运行于 UI 线程,若想依靠其完成耗时任务需要自己建立子线程,比较繁琐,官方提供的 IntentService 恰好解决这一问题;
- 分担 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() 启动、服务停止会清空待处理消息,因此它更适合"低并发、高优先级、自动收尾"的后台任务,而不是高并发的任务分发中心。