发表Android14 分钟读完 (大约2069个字)

Android IntentService 源码分析

01.整体源码展示及归纳

  • IntentService实际上内部实例化了一个HandlerThread,并且封装了一个Handler，所以他的工作流程通过上面的源码，分析如下：

    • 创建一个HandlerThread,开启HandlerThread来创建Looper
    • 创建一个Handler,传入Looper，从而在子线程实例化Handler
    • 在onStartCommand中获取到的Intent作为消息的obj发送出去
    • 然后在onHandleIntent中处理这个消息，注意此时是在子线程
    • 跟HandlerThread一样,IntentService内部是采用Handler来实现的，所以任务是串行执行的，不适用于大量耗时操作。

  • 源码如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    /**
     * 初始化工作，子线程，处理耗时操作和避免在application做过多初始化工作，比如初始化数据库等等
     */
    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()方法中

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    // 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传递给服务并且依次插入到工作队列中

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    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为子线程。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    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源代码

    1
    2
    3
    4
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

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

#

最新文章

分类

标签

CentOS2
Docker1
Dubbo7
JDBC1
JPMS1
JVM3
Kafka1
LLM1
MySQL1
Nacos21
Seata13
Sentinel18
Spring Cloud39
Spring Cloud Alibaba66
Spring Cloud Gateway6
Stable Diffusion2
TCP/IP1
ZooKeeper19
gcc1
modules1
mysql1
nginx1
nio1
分布式10
分布式事务14
加密1
基础672
多线程1
安全2
应用层1
数据库2
数据结构与算法36
方案1
源码解析18
知识点22
缓存1
网络1
设计模式25
语法1
调优2
集合4
面试题2
×