Android IntentService源码分析

每天一篇系列：
强化知识体系，查漏补缺。
欢迎指正，共同学习！

IntentService是一个Android基础类，用于处理Intent类型的异步任务请求。当客户端调用android.content.Context#startService(Intent)发送请求时，Service服务被启动，且在其内部构建一个工作线程来处理Intent请求。当工作线程执行结束，Service服务会自动停止。
IntentService是一个抽象类，用户必须实现一个子类去继承它，且必须实现IntentService里面的抽象方法onHandleIntent来处理异步任务请求。

public class DownLoadService extends IntentService {

    public static final String TAG = "DownLoadService";
    //重写默认的构造方法
    public DownLoadService() {
        super("DownLoadService");
    }

    //在后台线程执行
    @Override
    protected void onHandleIntent(Intent intent) {
        int key = intent.getIntExtra("key", 0);
        String value = intent.getStringExtra("value");
        switch (key) {
            case 1:
                //模拟耗时任务1
                try {
                    Thread.sleep(3 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                break;
            case 2:
                //模拟耗时任务1
                try {
                    Thread.sleep(3 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                break;
            default:
                break;
        }

        Log.e(TAG, "\nthe current time is: " + System.currentTimeMillis()/1000
                + "\nthe Thread id is " + Thread.currentThread().getId()
                + "\nthe current task is " + value);
    }
}

IntentService源码分析:

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

    public IntentService(String name) {
        super();
        mName = name;
    }
    ...
}

首先IntentService继承了Service，生命周期还是从OnCreat，onStartCommand/onBind，onDestroy。只不过IntentService重写了这些方法，在子类中不需要再重写。

   @Override
    public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.

        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
    
    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);
        }
    }

    protected abstract void onHandleIntent(Intent intent);

在onCreate()阶段，创建了HandlerThread，并且创建了一个Handler，Handler的Looper是HandlerThread的Looper。这样处理的话相当于创建一个带有消息队列的线程，耗时操作可以在HandlerThread这条线程中处理。可以看到Handler的消息都传递给onHandleIntent，而onHandleIntent是一个抽象方法，需要子类重写。这样也就是把耗时操作放置在HandlerThread线程中，用户可以重写onHandleIntent实现耗时操作处理，处理完毕后调用：

    stopSelf(msg.arg1);

    public final void stopSelf() {
        stopSelf(-1);
    }
    public final void stopSelf(int startId) {
        if (mActivityManager == null) {
            return;
        }
        try {
            mActivityManager.stopServiceToken(
                    new ComponentName(this, mClassName), mToken, startId);
        } catch (RemoteException ex) {
        }
    }

等待耗时操作处理完毕以后，IntentService就会自动退出，生命周期终止。

IntentService借助HandlerThread来完成了异步消息的处理，那么HandlerThread和Thread有什么区别呢？

HandlerThread handlerThread = new HandlerThread("test");
handlerThread.start();

HandlerThread源码分析：

public class HandlerThread extends Thread {
int mPriority;
    int mTid = -1;
    Looper mLooper;

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

HandlerThread继承于Thread，Thread内部肯定有run()方法，看看HandlerThread内部的run实现：

   @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

果然没错，可以看到调用start的时候，run函数开始执行：

    Looper.prepare();

多么熟悉的代码，还记得之前文章中分析的嘛，UI线程不也是这样创建Looper的。

    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

在run方法里面新建了一个Looper，并且同步了notifyAll()通知Looper创建完了。
接下来：

  onLooperPrepared();
  Looper.loop();

最重要的是Looper.loop()这个方法，在Hander机制中我分析过，是不断的从MessageQueue中获取消息让后分发给指定的Handler。
Handler创建完后，需要和Handler绑定，这样才能消息处理，创建指定Looper的Handler：

        Handler mHandler = new Handler(handlerThread.getLooper(), new Handler.Callback() {
            @Override
            public boolean handleMessage(Message msg) {
                //实现自己的消息处理
                return true;
            }
        });

在HandlerThread创建成功后，通过getLooper就可以获得Looper对象，因此Handler，Looper，MessageQueue就完成了消息事件机制。

    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        
        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

到这里，其实就可以总结出HandlerThread和Thread的差别了，HandlerThread在Thread的基础上添加了一个Looper+Handler，在有消息时分发消息处理，没有消息时阻塞式等待消息而不是退出。Thread在处理完耗时操作后就会退出线程。
IntentService借助HandlerThread来区别Service，在新的工作线程中来处理耗时任务，好处也就不言而喻了吧。