目录介绍
- 1.IntentService的作用
- 2.IntentService使用场景
- 3.IntentService使用步骤
- 4.IntentService源码分析
- 4.1 整体源码展示及归纳
- 4.2 如何单独开启1个新的工作线程
- 4.3 IntentService如何将Intent传递给服务并且依次插入到工作队列中
- 5.IntentService与其他线程对比
- 6.问题答疑解答
好消息
- 博客笔记大汇总【16年3月到至今】，包括Java基础及深入知识点，Android技术博客，Python学习笔记等等，还包括平时开发中遇到的bug汇总，当然也在工作之余收集了大量的面试题，长期更新维护并且修正，持续完善……开源的文件是markdown格式的！同时也开源了生活博客，从12年起，积累共计47篇[近20万字]，转载请注明出处，谢谢！
- 链接地址：https://github.com/yangchong211/YCBlogs
- 如果觉得好，可以star一下，谢谢！当然也欢迎提出建议，万事起于忽微，量变引起质变！
0.问题答疑
- 0.0.1 IntentService源码是如何设计的？原理是什么，有什么样的特点呢？
- 0.0.2 IntentService内部源码handler为何不会阻塞线程？
- 0.0.3 如果启动IntentService多次，会出现什么情况呢？
- 0.0.4 IntentService是如何单独开启1个新的工作线程？执行该线程有何特点？
- 0.0.5 如果intentService启动多次，那么IntentService如何通过onStartCommand()将Intent传递给服务 & 依次插入到工作队列中
- 0.0.6 多次开启intentService，那为什么工作任务队列是顺序执行的？
- 0.0.7 为什么不建议通过 bindService()启动IntentService，而是直接start开启service？
1.IntentService的介绍和作用
- IntentService的介绍
- IntentService是自己维护了一个线程，来执行耗时的操作，然后里面封装了HandlerThread，能够方便在子线程创建Handler。
- IntentService是继承自Service用来处理异步请求的一个基类，客户端startService发送请求，IntentService就被启动，然后会在一个工作线程中处理传递过来的Intent，当任务结束后就会自动停止服务。
- IntentService的作用
2.IntentService使用场景
- IntentService不需要我们自己去关闭Service，它自己会在任务完成之后自行关闭，不过每次只能处理一个任务，所以不适用于高并发，适用于请求数较少的情况
- 1.类似于APP的版本检测更新，后台定位功能以及读取少量的IO操作。
- 2.线程任务需按顺序、在后台执行，比如阿里云推送的服务service就是继承IntentSerVice
- 3.将部分application初始化的逻辑放到intentService里面处理，可以提高application启动时间
目前，由于正式项目中application初始化工作太多，所以决定分担部分逻辑到IntentService中处理
比如：现在application初始化内容有：数据库初始化，阿里云推送初始化，腾讯bugly初始化，im初始化，神策初始化，内存泄漏工具初始化，头条适配方案初始化，阿里云热修复……等等。将部分逻辑放到IntentService中处理，可以缩短很多时间。
3.IntentService使用步骤
- 步骤1：定义InitializeService类，并且需要继承IntentService的子类
- 需 传入线程名称、复写onHandleIntent()方法
- 步骤2：在清单文件Manifest.xml中注册服务
- 步骤3：开启该IntentService服务，并在onHandleIntent方法中做相关操作
//第一步
InitializeService.start(this);
//第二步
<service android:name=".InitializeService"/>
//第三步
public class InitializeService extends IntentService {
private static final String ACTION_INIT = "initApplication";
public static void start(Context context) {
Intent intent = new Intent(context, InitializeService.class);
intent.setAction(ACTION_INIT);
context.startService(intent);
}
public InitializeService(){
//注意这里需要写类的名称
super("InitializeService");
}
@Override
protected void onHandleIntent(Intent intent) {
if (intent != null) {
final String action = intent.getAction();
if (ACTION_INIT.equals(action)) {
initApplication();
}
}
}
private void initApplication() {
//处理耗时操作和避免在application做过多初始化工作，比如初始化数据库等等
}
}
4.IntentService源码分析
4.1 整体源码展示及归纳
- IntentService实际上内部实例化了一个HandlerThread,并且封装了一个Handler，所以他的工作流程通过上面的源码，分析如下：
- 创建一个HandlerThread,开启HandlerThread来创建Looper
- 创建一个Handler,传入Looper，从而在子线程实例化Handler
- 在onStartCommand中获取到的Intent作为消息的obj发送出去
- 然后在onHandleIntent中处理这个消息，注意此时是在子线程
- 跟HandlerThread一样,IntentService内部是采用Handler来实现的，所以任务是串行执行的，不适用于大量耗时操作。
- 源码如下所示：
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/01/22
* desc : 初始化工作，子线程，处理耗时操作和避免在application做过多初始化工作，比如初始化数据库等等
* revise:
* </pre>
*/
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);
}
}
/**
* 工作线程的名字
* @param name name
*/
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);
}
4.2 如何单独开启1个新的工作线程
// IntentService源码中的 onCreate() 方法
@Override
public void onCreate() {
super.onCreate();
// HandlerThread继承自Thread，内部封装了 Looper
//通过实例化andlerThread新建线程并启动
//所以使用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);
4.3 IntentService如何将Intent传递给服务并且依次插入到工作队列中
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();
}
5.IntentService与其他线程对比
- IntentService内部采用了HandlerThread实现，作用类似于后台线程；
- 与后台线程相比，IntentService是一种后台服务，优势是：优先级高（不容易被系统杀死），从而保证任务的执行
- 对于后台线程，若进程中没有活动的四大组件，则该线程的优先级非常低，容易被系统杀死，无法保证任务的执行
6.问题答疑解答
0.0.1 IntentService源码是如何设计的？原理是什么，有什么样的特点呢？
0.0.2 IntentService内部源码handler为何不会阻塞线程？
0.0.3 如果启动IntentService多次，会出现什么情况呢？
- IntentService多次被启动，那么onCreate()方法只会调用一次，所以只会创建一个工作线程。但是会调用多次onStartCommand方法，只是把消息加入消息队列中等待执行
0.0.4 IntentService是如何单独开启1个新的工作线程？执行该线程有何特点？
0.0.5 如果intentService启动多次，那么IntentService如何通过onStartCommand()将Intent传递给服务 & 依次插入到工作队列中
0.0.6 多次开启intentService，那为什么工作任务队列是顺序执行的？
- 结论：如果一个任务正在IntentService中执行，此时你再发送一个新的任务请求，这个新的任务会一直等待直到前面一个任务执行完毕才开始执行
- 分析：
- 由于onCreate() 方法只会调用一次，所以只会创建一个工作线程；
- 当多次调用 startService(Intent) 时（onStartCommand也会调用多次）其实并不会创建新的工作线程，只是把消息加入消息队列中等待执行，所以，多次启动 IntentService 会按顺序执行事件
- 如果服务停止，会清除消息队列中的消息，后续的事件得不到执行。
0.0.7 为什么不建议通过 bindService()启动IntentService，而是直接start开启service？
@Override
public IBinder onBind(Intent intent) {
return null;
}
- 在IntentService中，onBind()是默认返回null的，而采用bindService() 启动 IntentService的生命周期是：onCreate() —>onBind()—>onunbind()—>onDestory()
并不会调用onstart()或者onstartcommand()方法，所以不会将消息发送到消息队列，那么onHandleIntent()将不会回调，即无法实现多线程的操作。
关于其他内容介绍
01.关于博客汇总链接
02.关于我的博客
