7.3IntentService设计

目录介绍

  • 01.使用步骤
  • 02.具体案例
  • 03.打印日志
  • 04.IntentService作用
  • 05.IntentService使用场景

好消息

  • 博客笔记大汇总【16年3月到至今】，包括Java基础及深入知识点，Android技术博客，Python学习笔记等等，还包括平时开发中遇到的bug汇总，当然也在工作之余收集了大量的面试题，长期更新维护并且修正，持续完善……开源的文件是markdown格式的！同时也开源了生活博客，从12年起，积累共计N篇[近100万字，陆续搬到网上]，转载请注明出处，谢谢！
  • 链接地址：https://github.com/yangchong211/YCBlogs
  • 如果觉得好，可以star一下，谢谢！当然也欢迎提出建议，万事起于忽微，量变引起质变！

01.使用步骤

  • 步骤1：定义IntentService的子类：传入线程名称、复写onHandleIntent()方法
  • 步骤2：在Manifest.xml中注册服务
  • 步骤3：在Activity中开启Service服务

02.具体案例

  • 步骤1：定义IntentService的子类：传入线程名称、复写onHandleIntent()方法

    /**
 * <pre>
 *     @author yangchong
 *     blog  : https://github.com/yangchong211
 *     time  : 2017/01/22
 *     desc  : 初始化工作，子线程，处理耗时操作和避免在application做过多初始化工作，比如初始化数据库等等
 *     revise:
 * </pre>
 */
@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");
    }
}

  • 步骤2：在Manifest.xml中注册服务

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

  • 步骤3：在Activity中开启Service服务。博客

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

03.打印日志

  • 多次开启，打印日志如下
    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
  • 如果启动IntentService多次，会出现什么情况呢？
    • IntentService多次被启动，那么onCreate()方法只会调用一次，所以只会创建一个工作线程。但是会调用多次onStartCommand方法，只是把消息加入消息队列中等待执行
  • 多次开启intentService，那为什么工作任务队列是顺序执行的？
    • 结论：如果一个任务正在IntentService中执行，此时你再发送一个新的任务请求，这个新的任务会一直等待直到前面一个任务执行完毕才开始执行。博客
    • 分析：
        1. 由于onCreate() 方法只会调用一次，所以只会创建一个工作线程；
        1. 当多次调用 startService(Intent) 时（onStartCommand也会调用多次）其实并不会创建新的工作线程，只是把消息加入消息队列中等待执行，所以，多次启动 IntentService 会按顺序执行事件
        1. 如果服务停止，会清除消息队列中的消息，后续的事件得不到执行。

04.IntentService作用

  • IntentService的介绍
    • IntentService是自己维护了一个线程，来执行耗时的操作，然后里面封装了HandlerThread，能够方便在子线程创建Handler。
    • IntentService是继承自Service用来处理异步请求的一个基类，客户端startService发送请求，IntentService就被启动，然后会在一个工作线程中处理传递过来的Intent，当任务结束后就会自动停止服务。
  • IntentService的作用
    • 开启多线程
    • 执行异步请求逻辑
  • IntentService 有以下几个特性：
    • IntentService 内部创建了一个工作线程，用于在子线程内执行传递给 onStartCommand() 的所有 Intent，开发者无须关心多线程问题
    • IntentService 内部通过 HandlerThread 和 Handler 来实现异步操作
    • IntentService 是以串行方式处理外部传递来的任务，即只有当上一个任务完成时，新的任务才会被执行
    • 在处理完所有任务请求后会自动停止，因此不必手动调用 stopSelf() 方法
    • 提供了 onBind() 的默认实现（返回 null）
    • IntentService 是四大组件之一，拥有较高的优先级，不易被系统杀死，因此适合于执行一些高优先级的异步任务

05.IntentService使用场景

  • IntentService不需要我们自己去关闭Service，它自己会在任务完成之后自行关闭，不过每次只能处理一个任务，所以不适用于高并发，适用于请求数较少的情况。
  • 例如播放音乐、下载文件等，但 Service 默认是运行于 UI 线程的，如果想要依靠其来完成一些耗时任务，就需要自己来建立子线程，这相对比较繁琐，所以官方也为开发者提供了 IntentService 来解决这一问题
  • 1.类似于APP的版本检测更新，后台定位功能以及读取少量的IO操作。博客
  • 2.线程任务需按顺序、在后台执行，比如阿里云推送的服务service就是继承IntentSerVice
  • 3.将部分application初始化的逻辑放到intentService里面处理，可以提高application启动时间
目前，由于正式项目中application初始化工作太多，所以决定分担部分逻辑到IntentService中处理
比如：现在application初始化内容有：数据库初始化，阿里云推送初始化，腾讯bugly初始化，im初始化，神策初始化，内存泄漏工具初始化，头条适配方案初始化，阿里云热修复……等等。将部分逻辑放到IntentService中处理，可以缩短很多时间。
  • 使用场景可以参考：https://github.com/yangchong211/YCAudioPlayer

01.整体源码展示及归纳

  • 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);
}
  • 总结
    • 从上面源码可以看出，IntentService本质是采用Handler & HandlerThread方式：
      1. 通过HandlerThread单独开启一个名为IntentService的线程
      1. 创建一个名叫ServiceHandler的内部Handler
      1. 把内部Handler与HandlerThread所对应的子线程进行绑定
      1. 通过onStartCommand()传递给服务intent，依次插入到工作队列中，并逐个发送给onHandleIntent()
      1. 通过onHandleIntent()来依次处理所有Intent请求对象所对应的任务

02.开启1个新的工作线程

  • 如何单独开启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);

03.工作任务队列是顺序执行的

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

04.IntentService与Service区别

  • IntentService与Service区别
    • Service：依赖于应用程序的主线程（不是独立的进程 or 线程）
      • 不建议在Service中编写耗时的逻辑和操作，否则会引起ANR；
    • IntentService：创建一个工作线程来处理多线程任务
      • Service需要主动调用stopSelft()来结束服务，而IntentService不需要（在所有intent被处理完后，系统会自动关闭服务）
  • IntentService与其他线程的区别
    • IntentService内部采用了HandlerThread实现，作用类似于后台线程；博客
    • 与后台线程相比，IntentService是一种后台服务，优势是：优先级高（不容易被系统杀死），从而保证任务的执行。
      • 对于后台线程，若进程中没有活动的四大组件，则该线程的优先级非常低，容易被系统杀死，无法保证任务的执行

05.HandlerThread深入分析

  • HandlerThread继承Thread，它是一种可以使用Handler的Thread，它的实现也很简单，在run方法中也是通过Looper.prepare()来创建消息队列，并通过Looper.loop()来开启消息循环（与我们手动创建方法基本一致），这样在实际的使用中就允许在HandlerThread中创建Handler了。
  • 由于HandlerThread的run方法是一个无限循环，因此当不需要使用的时候通过quit或者quitSafely方法来终止线程的执行。
  • HandlerThread的本质也是线程，所以切记关联的Handler中处理消息的handleMessage为子线程。
    public class HandlerThread extends Thread {

    //线程优先级
    int mPriority;
    int mTid = -1;
    Looper mLooper;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
    

    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }
    

    protected void onLooperPrepared() {
    }

    @Override
    public void run() {
        //获取进程ID
        mTid = Process.myTid();
        //Loopr准备
        Looper.prepare();
        //创建Looper
        synchronized (this) {
            mLooper = Looper.myLooper();
            //唤醒所有等待的线程
            notifyAll();
        }
        //设置线程优先级
        Process.setThreadPriority(mPriority);
        //在Looper循环时做一些准备工作
        onLooperPrepared();
        //开启循环
        Looper.loop();
        mTid = -1;
    }
    
 
    public Looper getLooper() {
        //如果线程已经消亡，就返回null
        if (!isAlive()) {
            return null;
        }
        //如果线程已经创建了，就在此处停留等待Looper创建完成之后
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                //等待线程被创建
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

    public boolean quit() {
        //获取looper
        Looper looper = getLooper();
        if (looper != null) {
            //退出looper
            looper.quit();
            return true;
        }
        return false;
    }

    //安全退出
    //跟quit方法的唯一区别在于looper.quit()变成了looper.quitSafely()
    public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }

    /**
     * Returns the identifier of this thread. See Process.myTid().
     */
    public int getThreadId() {
        return mTid;
    }
}

06.可以bind开启IntentService吗

  • 首先先看看IntentService源代码
    @Override
public IBinder onBind(Intent intent) {
    return null;
}
  • 在IntentService中，onBind()是默认返回null的，而采用bindService() 启动 IntentService的生命周期是：onCreate() —>onBind()—>onunbind()—>onDestory() 并不会调用onstart()或者onstartcommand()方法，所以不会将消息发送到消息队列，那么onHandleIntent()将不会回调，即无法实现多线程的操作。

其他介绍

01.关于博客汇总链接

02.关于我的博客

  • github：https://github.com/yangchong211
  • 知乎：https://www.zhihu.com/people/yczbj/activities
  • 简书：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
  • 掘金：https://juejin.im/user/5939433efe88c2006afa0c6e
贡献者: yangchong211