IntentService 源码理解

亦凉 2024-03-31 08:23 34阅读 0赞

## 一、概述 ##

本篇文章讲解的是分析IntentService源码并使用，安卓API迭代更新的太快，IntentService已经在Android8.0 (API 26)之后就不推荐使用了，在Android API 30正式弃用，官方建议用JobIntentService 或 WorkManager替代，但它的实现源码和思想也值得再回味一下。读本篇文章之前，请移步笔者的另外一篇文章：

[HandlerThread源码理解\_broadview\_java的博客-CSDN博客][HandlerThread_broadview_java_-CSDN] ， 理解HandlerThread的用法后，对理解IntentService 也会事半功倍。

## 二、IntentService是什么 ##

#### 2.1 概述 ####

IntentService 继承了Service，并且它是一个**抽象类**，它又比普通的Service增加了额外的功能。那Google为什么要引入IntentService呢？

1. 我们知道Service它是一个服务，是Android四大组件之一，它和应用程序处于同一个进程之中

2. Service也不是一个线程，和线程完全没有关系，所以你在Service中直接处理耗时的任务，容易引起ANR。如果要做耗时任务，还必须要手动开启一个线程去处理任务。

3. 从Service的生命周期管理角度来看，startService启动服务，当做完任务后，还需要调用stopService停止服务。

但是 IntentService 就不需要考虑这么多，**它既不需要去我们手动去开线程，也不需要我们做完任务后手动停止服务**。

#### 2.2 特征 ####

1. IntentService 会创建单独的work线程来处理所有的Intent请求，开发者无需处理多线程问题

2. IntentService可用于执行后台耗时任务，当所有请求处理完成后，IntentService会自动停止

3. IntentService是一个服务，四大组件之一，所以它的优先级肯定要比单独创建出来一个线程优先级要高，因此也不容易被系统kill掉，可以保证后台任务能完成。

## 三、源码分析 ##

//IntentService首先是一个抽象类，类中只有一个abstarct抽象方法：onHandleIntent
    //所以我们需要重写onHandleIntent这个方法
    public abstract class IntentService extends Service {
        private volatile Looper mServiceLooper;
        @UnsupportedAppUsage
        private volatile ServiceHandler mServiceHandler;
        private String mName;
        private boolean mRedelivery;
        
        //内部ServiceHandler，用于线程间通信
        //这里是消息处理端，对应于 onStar()消息发送端
        private final class ServiceHandler extends Handler {
            public ServiceHandler(Looper looper) {
                super(looper);
            }
    
            @Override
            public void handleMessage(Message msg) {
                //此方法用于处理耗时逻辑任务
                onHandleIntent((Intent)msg.obj); 
                //当所有任务执行完毕后，就停止服务
                stopSelf(msg.arg1); 
            }
        }
    
        /**
         * Creates an IntentService.  Invoked by your subclass's constructor.
         * 通过名称来创建IntentService
         * @param name Used to name the worker thread, important only for debugging.
         */
        public IntentService(String name) {
            super();
            mName = name;
        }
    
        /**
         * Sets intent redelivery preferences.  Usually called from the constructor
         * with your preferred semantics.
         *
         * <p>If enabled is true,
         * {@link #onStartCommand(Intent, int, int)} will return
         * {@link Service#START_REDELIVER_INTENT}, so if this process dies before
         * {@link #onHandleIntent(Intent)} returns, the process will be restarted
         * and the intent redelivered.  If multiple Intents have been sent, only
         * the most recent one is guaranteed to be redelivered.
         *
         * <p>If enabled is false (the default),
         * {@link #onStartCommand(Intent, int, int)} will return
         * {@link Service#START_NOT_STICKY}, and if the process dies, the Intent
         * dies along with it.
         */
        public void setIntentRedelivery(boolean enabled) {
            mRedelivery = enabled;
        }
        
        
        @Override
        public void onCreate() {
            super.onCreate();
            //内部还是由 HandlerThread  +  Handler 来实现的
            HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
            //HandlerThread在线程内部创建Looper和消息队列，并且在线程启动之后开启消息循环
            thread.start();
            
            //获取工作线程的Looper
            mServiceLooper = thread.getLooper();
            //创建ServiceHandler，绑定工作线程的Looper，这样子ServiceHandler就可以往消息队
            //中分发消息
            mServiceHandler = new ServiceHandler(mServiceLooper);
        }
    
        @Override
        public void onStart(@Nullable Intent intent, int startId) {
            Message msg = mServiceHandler.obtainMessage();
            msg.arg1 = startId;
            msg.obj = intent;
            //发送消息，添加到消息队列
            mServiceHandler.sendMessage(msg);
        }
    
        /**
         * You should not override this method for your IntentService. Instead,
         * override {@link #onHandleIntent}, which the system calls when the IntentService
         * receives a start request.
         * @see android.app.Service#onStartCommand
          自定义的IntentService 可以不用复写 onStartCommand方法，但是一定要复写onHandleIntent方法
         */
        @Override
        public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
            //调用onStart(intent, startId)方法
            onStart(intent, startId);
            return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
        }
    
        @Override
        public void onDestroy() {
            mServiceLooper.quit();
        }
    
        /**
         * Unless you provide binding for your service, you don't need to implement this
         * method, because the default implementation returns null.
         * @see android.app.Service#onBind
         */
        @Override
        @Nullable
        public IBinder onBind(Intent intent) {
            return null;
        }
    
        /**
         * This method is invoked on the worker thread with a request to process.
         * Only one Intent is processed at a time, but the processing happens on a
         * worker thread that runs independently from other application logic.
         * So, if this code takes a long time, it will hold up other requests to
         * the same IntentService, but it will not hold up anything else.
         * When all requests have been handled, the IntentService stops itself,
         * so you should not call {@link #stopSelf}.
         *
         * @param intent The value passed to {@link
         *               android.content.Context#startService(Intent)}.
         *               This may be null if the service is being restarted after
         *               its process has gone away; see
         *               {@link android.app.Service#onStartCommand}
         *               for details.
         */
        //在自己的IntentService中重写此方法
        @WorkerThread
        protected abstract void onHandleIntent(@Nullable Intent intent);
    }

3.1 onCreate()方法

@Override
        public void onCreate() {
            super.onCreate();
            //内部还是由 HandlerThread  +  Handler 来实现的
            HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
            //HandlerThread在线程内部创建Looper和消息队列，并且在线程启动之后开启消息循环
            thread.start();
            
            //获取工作线程的Looper
            mServiceLooper = thread.getLooper();
            //创建ServiceHandler，绑定工作线程的Looper，这样子ServiceHandler就可以往消息队
            //中分发消息
            mServiceHandler = new ServiceHandler(mServiceLooper);
        }

参考之前写的HandlerThread源码理解，我们知道 IntentService 其实内部封装了 HandlerThread + Handler ，这也解释了它可以用来执行后台任务，而不会阻塞UI线程引起ANR。

3.2 onStartCommand()方法

@Override
        public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
            //调用onStart(intent, startId)方法
            onStart(intent, startId);
            return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
        }

补充一下基础知识，在Service生命周期中，当第一次用startService方法启动服务时回调：

onCreate()---->onStartCommand() ； 如果再启动该正在运行的服务，它不会再走onCreate()

只会走onStartCommand() ，源码中接着会调用onStart(intent, startId) 方法，这里也可以延伸一下，我们在实际应用中，就可以多次调用startService()方法来执行多项后台任务，IntentService也会多次调用 onStart(intent, startId)方法 ，我们来看看此方法

3.3 onStart(@Nullable Intent intent, int startId) 方法

@Override
        public void onStart(@Nullable Intent intent, int startId) {
            Message msg = mServiceHandler.obtainMessage();
            msg.arg1 = startId;
            msg.obj = intent;
            //发送消息，添加到消息队列
            mServiceHandler.sendMessage(msg);
        }

也就是每调用一下此方法，就会封装一个不同 startID 的Message对象，然后通过mServiceHandler分发到工作线程中去处理，由于HandlerThread 是单线程工作，所以这些任务就需要排队一个一个的处理，待处理完毕，就停止服务，这也是设计巧妙的地方，避免了多次创建IntentService.

3.4 onDestory()方法

@Override
        public void onDestroy() {
            mServiceLooper.quit();
        }

Looper消息轮询器退出

3.5 stopSelf(int startId)方法

此方法不同于Service的stopSelf()方法，当onHandlerIntent方法执行结束后，IntentService会通过stopSelf(int startId)方法来尝试停止服务。这里之所以采用stopSelf(int startId)而不是stopSelf()方法，那是因为stopSelf()会立即停止运行的服务，而这个时候可能还有其他消息未处理，stopSelf(int startId)则会等待所有的消息都处理完毕后才会停止服务。一般来说stopSelf(int startId)在尝试停止服务之前会判断最近启动的服务次数是否和startId相等，如果相等就立刻停止服务，不相等则不停止服务，这个策略可以从 AMS 的 public boolean stopServiceToken(ComponentName className, IBinder token, int startId) 这个方法中去查证。

## 四、实例演示 ##

首先我在IntentService源码中加两句打印log：

![8c4c3ab160d44a078f8c93179b866bde.png][]

然后编译替换 framework.jar

下面是Demo代码：

public class MainActivity extends AppCompatActivity {
    
        private Button mStartButton;
        private Button mStopButton;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            mStartButton = findViewById(R.id.service_start);
    
            Intent intent = new Intent(this, MyIntentService.class);
    
            mStartButton.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    intent.putExtra("task_id", "任务1");
                    startService(intent);
    
                    intent.putExtra("task_id", "任务2");
                    startService(intent);
    
                    intent.putExtra("task_id", "任务3");
                    startService(intent);
                }
            });
    
        }
    }

public class MyIntentService extends IntentService {
    
        public MyIntentService() {
            super("myIntentService");
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            Log.d("test", "=====MyIntentService====onCreate====");
        }
    
        @Override
        protected void onHandleIntent(@Nullable Intent intent) {
            String taskName = intent.getStringExtra("task_id");
            Log.e("test", "mServiceHandler 处理线程名称：" + Thread.currentThread().getName());
            Log.d("test", "======通过线程睡眠10秒模拟耗时任务==="+ taskName + "====start======");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
            }
    
            Log.d("test", "======"+  taskName  + "====end======");
        }
    
        @Override
        public void onDestroy() {
            Log.e("test", "=====MyIntentService====onDestroy====");
            super.onDestroy();
        }

运行打印log如下：

![c7b86ab8be084c0097a23341d37a5965.png][]

通过上述log分析，我们可以得出如下结论：

1. 当执行多个耗时任务时，它的工作模式是单服务（一个IntentService），单线程顺序执行任务（任务1执行---> 执行任务2 ----> 执行任务3 ）----->退出服务

2. 睡眠10秒，模拟耗时任务，也不会引起ANR，说明是在子线程中执行任务，也和源码中IntentService 内部实现是HandlerThread 可以对应上。

我们把源码中IntentService加的log去掉，只打印任务执行相关的log，也更加清楚其执行过程：

11-18 18:06:20.251  3085  3085 D ok      : =====MyIntentService====onCreate====
    
    11-18 18:06:20.253  3085  3159 D ok      : ======通过线程睡眠10秒模拟耗时任务===任务1====start======
    11-18 18:06:30.253  3085  3159 D ok      : ======任务1====end======
    11-18 18:06:30.255  3085  3159 D ok      : ======通过线程睡眠10秒模拟耗时任务===任务2====start======
    11-18 18:06:40.255  3085  3159 D ok      : ======任务2====end======
    11-18 18:06:40.257  3085  3159 D ok      : ======通过线程睡眠10秒模拟耗时任务===任务3====start======
    11-18 18:06:50.257  3085  3159 D ok      : ======任务3====end======
    
    11-18 18:06:50.261  3085  3085 E ok      : =====MyIntentService====onDestroy====

好了，到这里就应该对IntentService的使用差不多明白了，多打印log调试理解的更深一点。

[HandlerThread_broadview_java_-CSDN]: https://blog.csdn.net/u012514113/article/details/127882535?spm=1001.2014.3001.5501
[8c4c3ab160d44a078f8c93179b866bde.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/939b31ee44954ab78fe06189a0d56609.png
[c7b86ab8be084c0097a23341d37a5965.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/1e395d5d11154cbdab7286b1c2ae22eb.png