Android 异步任务知识梳理(2) HandlerThread 源码解析

1、概述

刚开始接触HandlerThread是在看AsyncQueryHandler源码的时候，第一次眼看到HandlerThread这个名字，就在想这究竟是个Handler仍是个Thread，后来看了源码才发现它其实就是一个Thread，只不过能够经过它的getLooper返回的Looper做为Handler构造函数的参数，那么这个新建Handler全部message的执行都是在这个对应的Thread当中的，关于在项目当中如何用好HandlerThread，AsyncQueryHandler无疑是一个最好的例子。

2、源码

HandlerThread的代码不多，咱们一点点看：

int mPriority; //线程的优先级
int mTid = -1; //线程对应的pid，结束时为-1。
Looper mLooper; //对应的looper
复制代码

再看一下run方法：

<!-- HandlerThread.java -->
@Override
public  void run() {    
    mTid = Process.myTid();    
    Looper.prepare();    
    synchronized (this) {        
        mLooper = Looper.myLooper();         
        notifyAll();    
    }     
    Process.setThreadPriority(mPriority);     
    onLooperPrepared();    
    Looper.loop();    
    mTid = -1;
}
复制代码

第一步先调用了Looper.prepare()方法来初始该线程的Looper，它实际上是新建了一个Looper（这个 Looper是能够退出循环的），保存到sThreadLocal变量当中，这个变量是static final ThreadLocal<Looper>类型的，也就是每一个Thread有一份不一样的实例，而且在每一个线程中也只容许初始化一次：

<!-- Looper.java -->

private Looper(boolean quitAllowed) {    
    mQueue = new MessageQueue(quitAllowed);    
    mThread = Thread.currentThread();
}

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));
}
复制代码

以后拿出这个新建的Looper保存起来，同时设置线程的优先级，接着调用Looper.loop()方法，在这以前会回调给onLooperPrepared，由于若是Looper.loop()开始执行后，那么就是一个无限循环，用户无法进行初始化操做了：

<!-- Looper.java -->
public static void loop() {
     final Looper me = myLooper();
     if (me == null) {
         //exception;
     }
     final MessageQueue queue = me.mQueue;
     Binder.clearCallingIdentity();
     final long ident = Binder.clearCallingIdentity();
     for (;;) {
        //这里面会调用 nativePollOnce(ptr, nextPollTimeoutMillis) 等待有新的消息出现，不然就一直阻塞在这里;
        Message msg = queue.next();
        //若是新的消息为null，那么就退出这个循环。
        if (message == null) {
            return;
        }
        //分发有效的消息。
        msg.target.dispatchMessage(msg);
        msg.recycleUnchecked();
     }
}

<!-- MessageQueue.java -->
Message next() {
   final long ptr = mPtr;
   if (ptr == null) {
      return null;
   }
   for (;;) {
       //会休眠在这里，直到经过mPtr被唤醒。 
       nativePollOnce(ptr, nextPollTimeoutMillis);
       //被唤醒后，从队列中去除消息进行处理。
   }
}
复制代码

接下来看一下getLooper()方法，若是此时mLooper尚未被初始化，那么它会一直休眠在这里：

<!-- HandlerThread.java -->
public Looper getLooper() {
    //若是线程没有存活，那么退出。    
    if (!isAlive()) {        
        return null;    
    }          
    synchronized (this) {
        //若是线程存活，可是没有开始运行，那么等待。        
        while (isAlive() && mLooper == null) {             
            try {                
                wait();            
            } catch (InterruptedException e) {}         
        }    
     }    
     return mLooper;
}
复制代码

这下来看一下退出的两个方法，它们的区别就是safe方法会保证当前队列当中的Message都被执行完毕，但那些delay的消息不会被递送。

<!-- HandlerThread.java -->
public boolean quit() {    
    Looper looper = getLooper();    
    if (looper != null) {        
        looper.quit();        
        return true;    
    }    
    return false;
}

public boolean quitSafely() {    
    Looper looper = getLooper();    
    if (looper != null) {        
        looper.quitSafely();        
        return true;    
    }    
    return false;
}
复制代码

quit实际上是调用了和Looper关联的MessageQueue对应的quit(boolean safe)方法：

<!-- Looper.java -->
public void quit() {    
    mQueue.quit(false);
}

public void quitSafely() {      
    mQueue.quit(true);
}

<!-- MessageQueue.java -->
void quit(boolean safe) {
    if (!mQuitAllowed) {    
        throw new IllegalStateException("Main thread not allowed to quit.");
    }
    
    synchronized (this) {    
        if (mQuitting) {        
            return;    
        }    
        mQuitting = true;    
        if (safe) {        
            removeAllFutureMessagesLocked();     
        } else {        
            removeAllMessagesLocked();    
        }
        //唤醒循环，使得 loop 知道，mQuitting 的变化    
        nativeWake(mPtr);
    }
}
复制代码

能够看到这里把mQuitting置为了true，以后经过nativeWake使Message.next()中 原先阻塞的 nativePollOnce继续往下执行而且会返回null，当Looper.loop()中的queue.next()返回null ，那么 Looper.loop()也跟着退出了。 因而可知当咱们实例化一个HandlerThread对象，以后又调用了quitXXX方法，那么它就中止了这个循环，至关于这个Looper对象在这个线程中虽然存在，可是没法经过它作任何操做了，即便咱们第二次执行它的run方法，调用Looper.prepare()的时候，也会由于sThreadLocal.get() != null而抛出异常。

3、结论

能够看到，HandlerThread就是建立了一个线程，当咱们调用它的start()方法时，也就是执行它的run方法，其实就是建立一个与他相关联的Looper，并让这个Looper跑起来，这个Looper中全部消息的处理都是在这个新建的线程当中的，调用者能够经过这个Looper进行后续的操做。