IntentService源码分析

时间 2020-02-14

标签 intentservice 源码分析繁體版

原文原文链接

目录介绍

1.IntentService的做用
2.IntentService使用场景
3.IntentService使用步骤
4.IntentService源码分析php
- 4.1 总体源码展现及概括
- 4.2 如何单独开启1个新的工做线程
- 4.3 IntentService如何将Intent传递给服务而且依次插入到工做队列中
5.IntentService与其余线程对比
6.问题答疑解答

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的介绍android
- IntentService是本身维护了一个线程，来执行耗时的操做，而后里面封装了HandlerThread，可以方便在子线程建立Handler。
- IntentService是继承自Service用来处理异步请求的一个基类，客户端startService发送请求，IntentService就被启动，而后会在一个工做线程中处理传递过来的Intent，当任务结束后就会自动中止服务。
IntentService的做用git
- 开启多线程
- 执行异步请求逻辑

2.IntentService使用场景

IntentService不须要咱们本身去关闭Service，它本身会在任务完成以后自行关闭，不过每次只能处理一个任务，因此不适用于高并发，适用于请求数较少的状况
1.相似于APP的版本检测更新，后台定位功能以及读取少许的IO操做。
2.线程任务需按顺序、在后台执行，好比阿里云推送的服务service就是继承IntentSerVice
3.将部分application初始化的逻辑放到intentService里面处理，能够提升application启动时间

目前，因为正式项目中application初始化工做太多，因此决定分担部分逻辑到IntentService中处理
好比：如今application初始化内容有：数据库初始化，阿里云推送初始化，腾讯bugly初始化，im初始化，神策初始化，内存泄漏工具初始化，头条适配方案初始化，阿里云热修复……等等。将部分逻辑放到IntentService中处理，能够缩短不少时间。

使用场景能够参考：https://github.com/yangchong2...

3.IntentService使用步骤

步骤1：定义InitializeService类，而且须要继承IntentService的子类github
- 需传入线程名称、复写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个新的工做线程

在onCreate()方法中

// 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个新的工做线程？执行该线程有何特色？

看4.2源码分析

0.0.5 若是intentService启动屡次，那么IntentService如何经过onStartCommand()将Intent传递给服务 & 依次插入到工做队列中

看4.3源码分析

0.0.6 屡次开启intentService，那为何工做任务队列是顺序执行的？

结论：若是一个任务正在IntentService中执行，此时你再发送一个新的任务请求，这个新的任务会一直等待直到前面一个任务执行完毕才开始执行
分析：segmentfault
- 1. 因为onCreate() 方法只会调用一次，因此只会建立一个工做线程；
- 1. 当屡次调用 startService(Intent) 时（onStartCommand也会调用屡次）其实并不会建立新的工做线程，只是把消息加入消息队列中等待执行，因此，屡次启动 IntentService 会按顺序执行事件
- 1. 若是服务中止，会清除消息队列中的消息，后续的事件得不到执行。

0.0.7 为何不建议经过 bindService()启动IntentService，而是直接start开启service？

首先先看看IntentService源代码

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

在IntentService中，onBind()是默认返回null的，而采用bindService() 启动 IntentService的生命周期是：onCreate() —>onBind()—>onunbind()—>onDestory()

并不会调用onstart()或者onstartcommand()方法，因此不会将消息发送到消息队列，那么onHandleIntent()将不会回调，即没法实现多线程的操做。多线程

关于其余内容介绍

01.关于博客汇总连接

02.关于个人博客

个人我的站点：www.yczbj.org，www.ycbjie.cn
github：https://github.com/yangchong211
知乎：https://www.zhihu.com/people/...
简书：http://www.jianshu.com/u/b7b2...
csdn：http://my.csdn.net/m0_37700275
喜马拉雅听书：http://www.ximalaya.com/zhubo...
开源中国：https://my.oschina.net/zbj161...
泡在网上的日子：http://www.jcodecraeer.com/me...
邮箱：yangchong211@163.com
阿里云博客：https://yq.aliyun.com/users/a... 239.headeruserinfo.3.dT4bcV
segmentfault头条：https://segmentfault.com/u/xi...