Handler消息处理机制---从源码分析

前言

android应用在启动时，默认会有一个主线程（ui线程），这个线程会关联一个消息队列，所有的操作都会被封装成消息进入消息队列交给主线程来处理，获取到的消息会放入一个死循环中，因此保证程序不会退出。那么handler和looper还有messageQueen和线程到底有什么关系呢？带着这种疑问，我们从handler的源码开始入手分析。

UI线程消息循环

ui线程的消息循环是在ActivityThread中的main方法里创建的，源码如下：

public static void main(String[] args) {
//...代码省略
Looper.prepareMainLooper();//创建主线程消息循环looper

ActivityThread thread = new ActivityThread();
thread.attach(false);

if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
AsyncTask.init();

Looper.loop();
throw new RuntimeException("Main thread loop uexpectedly exited");
}

我们可以看到，先调用了looper.prepareMainLooper()方法用来创建主线程的消息循环器，然后初始化主线程的handler，最后调用Looper.loop 方法开启循环，如果跳出循环则抛出异常。

Handler与Looper和消息队列的关系

我们平时在子线程执行玩耗时任务后经常用更新ui，必须在handler中执行。其实每个handler都会关联一个looper和looper中封装的消息队列，而每个looper又都会通过ThreadLocal关联一个线程，其实就相当于每个消息队列和一个线程关联，每个handler也关联一个线程。handler相当于一个消息处理器，将消息分发到消息队列，再由对应的线程从消息队列逐个取出消息来执行。那么handler是如何关联消息队列和线程的呢，我们看以下源代码：

public Handler(Callback callback, boolean async) {
//..省略
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;
}

调用默认的构造函数就会调用这个构造函数，可以看到构造函数里通过Looper.myLooper来获取Looper对象，同时关联了looper中的消息队列。

Looper与线程的关系

我们再看Looper中的源码：

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

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

public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}

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的构造函数里创建了messageQueen,并通过native方法Thread.currentThread获取当前线程。在myLooper方法中通过sThreadLocal.get方法来获取looper对象，那么looper对象又是什么时候存储到sThreadLocal中的？可以看到prepare方法中，如果looper已经存在就会抛出异常，不存在就会创建一个新的looper对象，并将该对象保存在sThreadLocal中。

结合上面handler的源码，也就是说，每个handler对象的创建，必须保证预先有一个Looper对象，否则会抛出异常”Can’t create handler inside thread that has not called Looper.prepare()”。我们在主线程中之所以不需要创建looper的原因是因为系统在启动一个应用的时候通过Looper.prepareMainLooper()为我们创建了一个与主线程关联的Looper对象，并且开启了loop循环器，所以我们在handler中发送的消息能被接受并处理。而我们在子线程中如果要创建handler发送和处理消息，必须遵循如下写法：

new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
Handler handler = new Handler();
Looper.loop();

}
}).start();

先通过Looper.prepare()方法初始化looper对象存入sThreadLocal方法中保证sThreadLocal.get不为null，这样初始化handler进入handler构造函数的时候就不会因为Looper.myLooper()方法调用sThreadLocal.get为空从而抛出异常了，最后调用Looper.loop开启循环。

那么我们在看看Looper.loop里面到底干了些什么:

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;//1.获取消息队列
//...代码省略
for (;;) {//2.消息循环
Message msg = queue.next(); // 3.获取消息
if (msg == null) {
return;
}

// This must be in a local variable, in case a UI event sets the logger
//...代码省略
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
msg.target.dispatchMessage(msg);//4.处理消息
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
msg.recycleUnchecked();//5.回收消息
}
}

可以看到，先通过Looper.myLooper方法获取looper对象和messageQueen对象，然后进入死循环不断地从消息队列取消息，最后处理消息的过程。

消息处理机制

我们从上面的代码中可以看到，通过msg.target.dispatchMessage(msg)来处理消息，那么msg.target又是什么呢？

public final class Message implements Parcelable {
/*package*/ Bundle data;

/*package*/ Handler target;

/*package*/ Runnable callback;

// sometimes we store linked lists of these things
/*package*/ Message next;
}

从源码可以看到，target也就是handler，实质是调用handler的dispatchMessage方法来分发消息。

我们继续看handler中的

public void handleMessage(Message msg) {
}

private static void handleCallback(Message message) {
message.callback.run();
}

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

可以看到，如果msg的callback线程不为空，则会调用handlerCallback,也就是调用msg中callback线程的run方法，如果为空则会交给handlerMessage来处理。那么什么时候callback为空什么时候不为空呢？我们继续往下看：

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

public final boolean post(Runnable r)
{
return  sendMessageDelayed(getPostMessage(r), 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);//将消息插入消息队列
}

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;//将handle引用赋给msg
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}

private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}

可以看到，在调用handler.post(Runnable r)时，会将Runnable包装成Message的callback，最后将包装后的message对象插入消息队列中，并且将handler的引用传递给message，这样就能在Looper.loop()中调用handler的dispatchMessage方法来进行消息的下发处理了。

sendMessage也是同样的实现，只不过没有包装的Runnable对象，所以调用该方法msg.callback==null,故这边就是交给handlerMessage来进行处理。

结语

handler会将每一个消息追加到消息队列中，通过Looper不断从消息队列中获取消息，并且调用handler的dispatchMessage分发消息，分发的消息再通过回调进行处理，这样，android就可以流畅的运转了。