Handler和HandlerThread

Hander

Hander的主要作用有两个：

1. 延迟处理消息。
2. 在其他线程处理消息。

这里的消息可以理解为Message和Runnable，通过如下方法来调度消息。

Runnable实际上是将该Runnable匿名对象排入队列，在其他线程执行该消息，这里的其他线程可以理解为MessageQueue所在的线程。

MessageQueue和Looper

MessageQueue是由Looper来创建的，通过与该Looper关联的Handler对象往里面添加消息。

public Handler(Callback callback, boolean async) {
    if (FIND_POTENTIAL_LEAKS) {
        final Class<? extends Handler> klass = getClass();
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                (klass.getModifiers() & Modifier.STATIC) == 0) {
            Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                klass.getCanonicalName());
        }
    }
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

这是Handler的构造函数，第10行代码可以看到在里面通过Looper.myLooper()获得了Looper对象。而2到9行代码是对Handler类是否为静态内部类的检测代码，否则会提示一个警告可能会造成内存泄漏。

另外一个值得注意的是第15行的mQueue = mLooper.mQueue, 可以看到Looper会把自己的MessageQueue对象交给Handler.

在Looper.java中找到静态方法myLooper,令人好奇的是sThreadLocal里面为什么可以通过get()方法获取到一个Looper对象。

public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<>();

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.prepare()中给sThreadLocal中设置了Looper对象，如果已经存在当前线程的Looper对象则不会再次创建，而且值得注意的是不要重复调用prepare()方法，否则会抛异常。

至此，我们已经验证了Handler中获得了当前线程的Looper对象，下面我们看看Looper是怎么创建MessageQueue的。

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

添加队列

我们来研究一下添加队列的过程。

public final boolean sendMessage(Message msg)
{
    return sendMessageDelayed(msg, 0);
}

public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, uptimeMillis);
}

你会发现最终发送的消息是通过sendMessageAtTime发送的，上面我们已经提到过了Looper将MessageQueue交给了Handler，来看看enqueueMessage方法。

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

请注意第2行的msg.target=this,也就是这个target是Handler对象。

至此，我们已经将消息添加到了MessageQueue了，接下来我们来看看Looper是怎么管理队列的。

管理队列

一般创建一个Handler的过程如下：

class LooperThread extends Thread {
    public Handler mHandler;

    public void run() {
        Looper.prepare();

        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };

        Looper.loop();
    }
}

这个Looper.loop()静态方法内有一个无限的for循环，在这个for循环中对队列数据进行了处理和分发，下面是部分代码：

public static void loop() {

    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;

    for (;;) {
         Message msg = queue.next(); // might block
         if (msg == null) {
             // No message indicates that the message queue is quitting.
             return;
         }

         try {
            msg.target.dispatchMessage(msg);
            end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }

    }

}

可以看到第17行的msg.target.dispatchMessage(msg)，哈哈，上面已经提到了这里的msg.target实际上是Handler对象。

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
     } else {
         if (mCallback != null) {
             if (mCallback.handleMessage(msg)) {
                 return;
             }
         }
         handleMessage(msg);
     }
 }

至此，整个过程已经完成，你会发现这个过程其实很简单。

HanderThread

到现在这个HandlerThread就很好理解了，它其实是是一个线程，继承自Thread类，可以说它是对Thread的一种Looper包装，它里面实现了Looper的创建。

通常情况下我们可以拿到该线程的Looper对象来创建Handler，这样Handler的消息处理就会在HandlerThread所在线程执行。

mSerialThread = new HandlerThread("serial-worker-thread");
mSerialThread.start();
mSerialThreadHandler = new Handler(mSerialThread.getLooper());

如果配合RxJava的线程调度就更妙了,哈哈。

Observable.create(new ObservableOnSubscribe<RecvCommand>() {
    @Override
    public void subscribe(ObservableEmitter<RecvCommand> emitter) throws Exception {

        //TODO Somethings
    }
}).subscribeOn(AndroidSchedulers.from(mSerialThread.getLooper()));

简单的说HandlerThread可以方便我们快速创建一个处理消息队列的线程，我们可以获取它的Looper对象来给相关Handler，相对应的Handler就可以给该线程发送消息。

最后我们看看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;
}