Android多线程之IntentService详解

一　概述

IntentService 是继承自 Service 并处理异步请求的一个类，在 IntentService 内有一个工作线程来处理耗时操作，其优先级比普通 Service 高。当任务完成后，IntentService 会自动停止，而不需要手动调用 stopSelf()。另外，可以多次启动 IntentService，每个耗时操作都会以工作队列的方式在 IntentService 中 onHandleIntent() 回调方法中执行，并且每次只会执行一个工作线程，因此我们直接实现虚函数 onHandleIntent，在里面根据 Intent 的不同进行不同的事务处理就可以了。

二　工作原理

IntentService 内在 onCreate() 时创建了一个 HandlerThread 和 ServiceHandler extends Handler。并重构了Handler 的 handleMessage 方法，在 handleMessage 方法内执行 onHandleIntent 和 stopSelf(id)。每次 onStartCommand 的接口调用时 ServiceHandler 都会发送相应的信息。

三　实例代码

大概了解了 IntentService 的特点后，我们就来了解一下它的使用方式，先看个案例：
IntentService 实现类如下：

public class HandlerThreadIntentService extends IntentService {

  /** 
    * 在构造函数中传入线程名字
    **/  
    public HandlerThreadIntentService() {
        // 调用父类的构造函数
        // 参数 = 工作线程的名字
        super("HandlerThreadIntentService");
    }

   /** 
     * 复写onHandleIntent()方法
     * 根据 Intent实现 耗时任务 操作
     **/  
    @Override
    protected void onHandleIntent(Intent intent) {
        // 根据 Intent的不同，进行不同的事务处理
        String taskName = intent.getExtras().getString("taskName");
        switch (taskName) {
            case "task1":
                Log.i("HandlerThreadIntentService", "do task1");
                break;
            case "task2":
                Log.i("HandlerThreadIntentService", "do task2");
                break;
            default:
                break;
        }
    }
}

            // 请求1
            Intent i = new Intent("cn.scu.finch");
            Bundle bundle = new Bundle();
            bundle.putString("taskName", "task1");
            i.putExtras(bundle);
            startService(i);

            // 请求2
            Intent i2 = new Intent("cn.scu.finch");
            Bundle bundle2 = new Bundle();
            bundle2.putString("taskName", "task2");
            i2.putExtras(bundle2);
            startService(i2);

四　源码分析

4.1 实例化以及内部类解析

public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

    private final class ServiceHandler extends Handler {
        //构造函数
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        //ServiceHandler接受的消息交给onHandleIntent()去处理
        @Override
        public void handleMessage(Message msg) {
            // onHandleIntent 方法在HandlerThread线程中执行
            onHandleIntent((Intent)msg.obj);
            //结束服务，这个时候有时是不能结束服务的，待会会解释
            stopSelf(msg.arg1);
        }
    }
    public IntentService(String name) {
        super();
        mName = name;
    }
    ......
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

自己重写了一个 Handler，将最终处理结果交付给 onHandleIntent() 方法去执行，并且执行完后会立马执行 stopSelf(Id) 方法，上面注释已经说明有时是不能结束 Service 的，待会单独解释。

4.2 启动IntentService#onCreate

    @Override
    public void onCreate() {
        super.onCreate();
        // 1. 通过实例化andlerThread新建线程 & 启动
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();
        // 2. 获得工作线程的 Looper & 维护自己的工作队列
        mServiceLooper = thread.getLooper();
       // 3. 新建mServiceHandler & 绑定上述获得Looper
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

启动 Service，会调用接口 onCreate()，这里面的操作和我们使用 HandlerThread 的实例代码差不多，而且 Handler 的实例化和内部回调方法已经在 IntentService 内部实现。

4.3 启动IntentService#onStartCommand

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

        @Override
    public void onStart(@Nullable Intent intent, int startId) {
        // 1. 获得ServiceHandler消息的引用
        Message msg = mServiceHandler.obtainMessage();
        // 2. 将当前启动的service的id转递进去，用于关闭service
        msg.arg1 = startId;
        // 2. 把 Intent参数 包装到 message 的 obj 发送消息中，
        msg.obj = intent;
        // 3. 发送消息
        mServiceHandler.sendMessage(msg);
    }

根据 Service 的启动机制我们知道每次 startService 时都会调用 onStartCommand 方法，进而会进入 onStart 方法，onStart 方法内将要传递的参数封装成 Message 作为消息通过 mServiceHandler 发送出去。

4.4 onHandleIntent执行位置

    private final class ServiceHandler extends Handler {
        //构造函数
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        //ServiceHandler接受的消息交给onHandleIntent()去处理
        @Override
        public void handleMessage(Message msg) {
            // onHandleIntent 方法在HandlerThread线程中执行
            onHandleIntent((Intent)msg.obj);
            //结束服务，这个时候有时是不能结束服务的，待会会解释
            stopSelf(msg.arg1);
        }
    }

最终还是来到 ServiceHandler#handleMessage() 方法内执行逻辑操作，所以要业务逻辑都要放到 onHandleIntent() 方法内实现。然后调用 stopSelf(Id) 来自动关闭 Service。

五　自动关闭stopSelf(int startId)

• onStartCommand(Intent intent, int flags,int startId) 方法中的 int startId 参数，该参数代表当前 service 中的 onStartCommand 方法被调用的次数
• 在当前 Service 实例没被销毁的情况下，onStartCommand 方法每被调用一次，传入的 startId 便会+1
• stopSelf(int startId) 传入的值和 onStartCommand 最后一次被调用时所被传入的 startId 值相同时，当前 Service 实例将被停止；如果不相同，则当前 Service 实例不会被停止
• stopSelf() 和 stopSelf(-1) 会立即停止 Service

六　总结

• 它本质是一种特殊的 Service，继承自 Service 并且本身就是一个抽象类
• 它可以用于在后台执行耗时的异步任务，当任务完成后会自动停止
• 它拥有较高的优先级，不易被系统杀死（继承自 Service 的缘故），因此比较适合执行一些高优先级的异步任务
• 它内部通过 HandlerThread 和 Handler 实现异步操作
• 创建 IntentService 时，只需实现 onHandleIntent 和构造方法，onHandleIntent 为异步方法，可以执行耗时操作