IntentService源码分析

yangchong211 / 文 发表于2018-09-17 17:49 次阅读

目录介绍

  • 1.IntentService的作用
  • 2.IntentService使用场景
  • 3.IntentService使用步骤
  • 4.IntentService源码分析
    • 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的介绍
    • 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中处理,可以缩短很多时间。
  • 使用场景可以参考:https://github.com/yangchong211/YCAudioPlayer

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个新的工作线程

  • 在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中执行,此时你再发送一个新的任务请求,这个新的任务会一直等待直到前面一个任务执行完毕才开始执行
- 分析:
    - 1. 由于onCreate() 方法只会调用一次,所以只会创建一个工作线程;
    - 2. 当多次调用 startService(Intent) 时(onStartCommand也会调用多次)其实并不会创建新的工作线程,只是把消息加入消息队列中等待执行,所以,多次启动 IntentService 会按顺序执行事件
    - 3. 如果服务停止,会清除消息队列中的消息,后续的事件得不到执行。

#### 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.关于博客汇总链接
- 1.[技术博客汇总](https://www.jianshu.com/p/614cb839182c)
- 2.[开源项目汇总](https://blog.csdn.net/m0_37700275/article/details/80863574)
- 3.[生活博客汇总](https://blog.csdn.net/m0_37700275/article/details/79832978)
- 4.[喜马拉雅音频汇总](https://www.jianshu.com/p/f665de16d1eb)
- 5.[其他汇总](https://www.jianshu.com/p/53017c3fc75d)

#### 02.关于我的博客
- 我的个人站点:www.yczbj.org,www.ycbjie.cn
- github:https://github.com/yangchong211
- 知乎:https://www.zhihu.com/people/yang-chong-69-24/pins/posts
- 简书:http://www.jianshu.com/u/b7b2c6ed9284
- csdn:http://my.csdn.net/m0_37700275
- 喜马拉雅听书:http://www.ximalaya.com/zhubo/71989305/
- 开源中国:https://my.oschina.net/zbj1618/blog
- 泡在网上的日子:http://www.jcodecraeer.com/member/content_list.php?channelid=1
- 邮箱:yangchong211@163.com
- 阿里云博客:https://yq.aliyun.com/users/article?spm=5176.100- 239.headeruserinfo.3.dT4bcV
- segmentfault头条:https://segmentfault.com/u/xiangjianyu/articles
收藏 赞 (0) 踩 (0)