HandlerThread与IntentService

一、HandlerThread
源码不多，直接全上

public class HandlerThread extends Thread {
    int mPriority; //线程优先级（注意是Process而不是Thread）
    int mTid = -1;//线程ID
    Looper mLooper;
    private @Nullable Handler mHandler;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
    
  
    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }
    
   /**
    * Looper loop之前的准备工作
    */
    protected void onLooperPrepared() {
    }
   /**
    * 本线程的run方法，内部主要执行Looper的初始化等操作
    */
    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }
    
   /**
    * 获取本线程Looper
    */
    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;
    }

   /**
    * 获取本线程Handler 
    */
    @NonNull
    public Handler getThreadHandler() {
        if (mHandler == null) {
            mHandler = new Handler(getLooper());
        }
        return mHandler;
    }

   /**
    * Looper 退出，实际执行的就是MessageQueue内部的quit方法，清空消息队列，因为safe参数传递为false，执行
    * removeAllMessagesLocked();
    */
    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }
   /**
    * 同上，区别是MessageQueue内部的quit方法的safe参数传递为true，从而调用removeAllFutureMessagesLocked()
    */
    public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }
   /**
    * 获取mTid
    */
    public int getThreadId() {
        return mTid;
    }
}

HandlerThread继承Thread类，主要作用就是封装了Looper 的准备等操作。假设XXXHandlerThread在继承HandlerThread后，利用XXXHandlerThread执行耗时操作时只需要获取XXXHandlerThread的handler，然后在该handler的handleMessage回调方法中进行耗时操作就可以，最后调用主线程handler更新UI即可。

二、IntentService
说完了HandlerThread，下面来看IntentService。源码不多，直接全上

public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;//内部HandlerThread对象的Looper 
    private volatile ServiceHandler mServiceHandler;//内部HandlerThread对象的Handler
    private String mName;//内部HandlerThread对象的name
    /**
     *用来确定onStartCommand返回值，true返回START_REDELIVER_INTENT（Service运行的进程被杀死后不再重新创建），
     *false返回START_NOT_STICKY（Service运行的进程被杀死后会重新创建，并保留intent信息，还有一种返回值为
     *START_STICKY，区别是不保留intent信息）
     */
    private boolean mRedelivery;
	 
    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);
        }
    }

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

   /**
    * 设置mRedelivery 值
    */
    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        //创建内部HandlerThread 对象，用来执行耗时操作
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();
	//获取HandlerThread 的Looper以及Handler
        mServiceLooper = thread.getLooper();
        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);
    }

    @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 onDestroy() {
        mServiceLooper.quit();
    }

    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }

   /**
    * onStartCommand中执行onStart方法，onStart方法中向mServiceHandler发送执行消息，在回调中执行onHandleIntent方法， 			
    * 所以在应用时只需要重写onHandleIntent方法，并在其内部执行耗时操作就可以了
    */
    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

因为Service默认运行在主线程中，而IntentService因为是通过内部持有的HandlerThread对象的handler将事件加入到该子线程的消息队列中去执行事件，所以事件是在单独的子线程中操作，因此可以直接在重写的onHandleIntent方法中进行耗时操作。
注意：IntentService不能用bindService创建，因为onHandleIntent方法是在onStartCommand中调用onStart执行，而bindService生命周期不会经历onStartCommand。