1. Handler简介
Handler机制，说的也是Android中的消息传递机制。也就是将工作线程（子线程）中创建的消息，传递到主线程，以进行UI更新操作的过程。简单的可理解为，子线程和主线程之间的通讯。采用这样的机制是为了防止并发更新UI所导致的线程安全问题，而不使用线程锁是为了提高系统的运行效率。
2.Handler简单使用
2.1 使用sendMessage()方法。
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
Message message = new Message();
message.what = 0x11;
message.obj = "异步创建字符串";
handler.sendMessage(message);
}
});
thread.start();
2.2 使用post方法
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
handler.post(new Runnable() {
@Override
public void run() {
textView.setText("异步创建字符串");
}
});
}
});
thread.start();
2.3 接收、处理消息
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 0x11:
String text = (String) msg.obj;
textView.setText(text);
break;
}
}
};
3.Handler相关方法
3.1 sendMessage系列
sendMessage()方法主要是用于发送一条消息。一般用法是通过重写handler的handler消息是通过Message进行封装。如：
Message message = new Message();
message.what = 0x11;
message.obj = "异步创建字符串";
message.arg1 = 1;
message.arg2 = 2;
handler.sendMessage(message);
- what字段一般用来表示事件类型，用int类型表示。
- arg1和arg2字段可以传递两个int类型的值。
- obj字段可以传递一个对象类型。
除了sendMessage方法可以调用外，还有如下方法：
sendEmptyMessage用户发送一条空消息，参数what用于表示一个消息类型。
- 后缀为Delayed的方法，表示延迟发送，delayMillis参数表示延迟的毫秒数。
- 后缀为AtTime的方法，表示指定时间发送，uptimeMillis参数指定发送的时间，也是毫秒级。
- 其实sendMessage()、sendMessageDelayed()方法，最终调用的还是sendMessageAtTime()方法，源码中的调用为：
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 final boolean sendEmptyMessage(int what) {
return sendEmptyMessageDelayed(what, 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
我们可以发现，sendEmptyMessage()方法，最终调用的是sendMessageDelayed()方法。是在sendEmptyMessageDelayed()方法中为我们创建了一个Message对象。
3.2 post系列
post方法主要是post一个Runnable对象，在Runnable的run方法中进行消息的处理，这种方法在使用方面不用自己去创建Message对象，但内部其实还是通过Message实现的。这种方法可以实现在子线程中方便的更新UI而不用去通过重写Handler的handleMessage()方法来更新UI。如：
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
handler.post(new Runnable() {
@Override
public void run() {
textView.setText("异步创建字符串");
}
});
}
});
thread.start();
同样，post也有延迟发送等方法：
4.消息机制
接下来通过源码来分析Handler的消息机制。
4.1 相关的类
- Handler 用于产生和处理消息
- Message 用于消息的封装
- MessageQueue 消息队列，用户存储消息。这个MessageQueue不是一个真正的队列，他并没有实现java的Queue接口，他实际上只是封装了一个单向链表，向外界提供了enqueueMessage()、next()等方法。
- Looper 轮询器，以轮询的方式从MessageQueue中查询消息，并将消息发送给Handler做处理。
- ThreadLocal 用于在线程中存储Looper，可以说实现了线程和Looper的绑定。
4.2 流程
下面一张图理解Handler、Message和MessageQueue之间的关系。
大概的流程为：handler发送message到MessageQueue中。Looper轮询MessageQueue，将消息发送给Handler进行处理。
4.3 Handler的创建过程
4.3.1 主线程中创建Handler
handle的创建只需要通过new Handler()就可以创建一个Handler。在创建handler的时候需要指定Looper，主线程的Looper是在ActivityThread的main方法中创建的，通过Looper.prepareMainLooper()方法进行创建。
/**
* Initialize the current thread as a looper, marking it as an
* application's main looper. The main looper for your application
* is created by the Android environment, so you should never need
* to call this function yourself. See also: {@link #prepare()}
*/
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
在prepareMainLooper方法中，sMainLooper通过myLooper()方法创建，而myLooper方法是通过调用ThreadLocal的get方法得到Looper对象。
/**
* Return the Looper object associated with the current thread. Returns
* null if the calling thread is not associated with a Looper.
*/
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
这里，先不具体讲ThreadLocal，简单的可理解为讲数据和线程做一个绑定，在当前线程中使用ThreadLocal.get()方法获取对象，则获取到的对象是当前线程所独立拥有的对象，和其他线程中的对象互不干扰。ThreadLocal中有一个Map，用来保存线程和数据的映射关系。
通过ThreadLocal.get()方法获取数据，首先要调用ThreadLocal.set()方法设置数据。所以刚才在myLooper方法中使用ThreadLocal.get()方法获取Looper对象，那是在什么时候设置进去的呢？答案就是prepareMainLooper方法中调用的prepare方法。
/** Initialize the current thread as a looper.
* This gives you a chance to create handlers that then reference
* this looper, before actually starting the loop. Be sure to call
* {@link #loop()} after calling this method, and end it by calling
* {@link #quit()}.
*/
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));
}
我们再看prepare(boolean)方法。这里首先调用了ThreadLocal.get()方法检查当前线程是否已经创建了Looper对象，如果创建了，就抛出一个RuntimeException。然后调用ThreadLocal.set()方法设置了一个新的Looper，quitAllowed参数是表示是否可以退出消息队列。
由于Looper的构造方法是私有的，所以我们需要通过Looper.prepare()方法来创建Looper。在Looper的构造方法中，创建了一个MessageQueue，并且获取了当前线程信息。
此时主线程中的Looper已经创建完成。再看ActivityThread的main方法，在main方法的最后，调用了Looper.loop()方法，之后抛出一个RuntimeException。此时我们是不是有疑问，为啥要抛出一个RuntimeException？我们知道java程序的入口是main方法，当main方法执行结束，也表示应用程序已经执行结束。所以我们应该会想到，作为一个Android应用程序，怎么可以刚打开就结束了呢。所以说正常情况下只不会执行结束的。关键就在于Looper.loop()方法。我们查看Looper.loop()方法：
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static void loop() {
//此处省略...........
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
//此处省略..........
}
//此处省略..........
}
在loop方法中有一个死循环，这个死循环就防止了应用程序执行结束。我们看到通过queue.next()方法拿到一个Message，queue的定义在loop方法中，并且在for循环之前：
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;
通过myLooper方法拿到当前线程的Looper对象me，并通过me.mQueue方法拿到了当前Looper对象中的MessageQueue，这个MessageQueue的创建是在前面讲到的Looper的构造方法中。通过MessageQueue.next()方法从MessageQueue中取得一个Message。
此时Handler、Looper、MessageQueue已经创建完成，并且Looper循环已经开启。只需要handler开始发送消息，并处理消息。
4.3.2 子线程中创建Handler
上面是从主线程的角度开始讲解Handler的创建过程，那子线程呢？
在子线程中使用Handler，首先需要new一个handler，此时handler中是没有Looper对象的。上面我们分析源码得出。Looper的构造方法是私有的，只能通过Looper.prepare()方法来创建当前线程的Handler，并且每个线程最多只能存在一个Looper对象，如果多次创建，会抛出RuntimeException。
所以我们在子线程中要使用Handler的时候，必须指定Looper。为什么说是指定而不是创建呢，因为我们可以通过Looper.getMainLooper()方法拿到主线程的Handler。当Looper指定完成以后，就可以通过Looper.loop方法开启循环。所以说，消息处于哪个线程的Looper中，则消息回调处理就在哪个线程中。
4.4 消息发送
4.4.1 使用Send方法发送Message
上面说到了sendMessage()方法最终都是调用了sendMessageAtTime()方法。我们看看sendMessageAtTime()方法做了什么操作。
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()方法中，首先检查了当前Handler是否指定了MessageQueue。如果没有指定，则返回false，如果已经指定，则执行了enqueueMessage()方法，我们再看enqueueMessage()方法。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
在这里我们就可以看明白，是在这个方法中将消息加入到MessageQueue中。并且在加入message之前，将msg的target字段赋值为this，这个this也就是当前的Handler对象了。mAsynchronous表示是否异步，这个参数是在handler创建的时候初始化的，默认为false。
4.4.2 使用Post方法发送Runnable
我们首先看Post方法中执行了什么操作。
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
我们发现post()方法直接调用的是sendMessageDelayed()方法。但是message的获取是通过getPostMessage()方法。我们看看getPostMessage()方法。
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
在getPostMessage()方法中通过Message.obtain()得到了一个Message对象，并且将runnable对象设置给message的callback，之后就返回了这个message对象。Message.obtain()方法简单理解是获取一个可复用的Message对象，降低了内存开销，提高效率。
所以说，我们使用post()方法最终还是通过Message，并且是将这个回调Runnable设置给Message对象中的callback属性。
4.5 消息的处理
我们回到Loop的loop()方法。
public static void loop() {
//... 省略
for (;;) {
//... 省略
try {
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
//... 省略
}
//... 省略
}
在loop()方法的for循环中，有一行代码。msg.target.dispatchMessage()。调用了message的target的dispatchMessage()方法。之前我们看过，message的target实际上是保存的当前Handler的实例，所以这里调用的是handler对象的dispatchMessage()方法进行消息的封发处理。我们查看dispatchMessage()方法。
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
这里我们发现，首先判断了msg的callback属性是否为null，这里的callback就是使用post方法传入的Runnable参数。
- 当callback不为null时，调用了handleCallback()方法
private static void handleCallback(Message message) {
message.callback.run();
}
handleCallback()方法直接调用了message.callback.run()，也就是调用了传入的Runnable的run方法。
- 当callback为null时，首先是判断了mCallback是否为null，不为null。则执行mCallback的handleMessage()方法，并且return。如果mCallback为null，则会调用handler的handleMessage方法。这个方法大家就很熟悉了，不就是我们重写的handler的handleMessage()用来处理消息的方法吗。
我们可以查看mCallback的初始化，其实是在Handler的构造方法中初始化的，可以传入一个Callback，实现Callback的handleMessage()方法。所以我们使用callback的handleMessage方法去处理消息，和重写handler的handleMessaeg()方法，都是可以实现消息回调处理的，但是callback的优先级在前。
从上面可以看出，我们可以重写dispatchMessage()方法进行消息的拦截处理。
写在最后
首先，谢谢大家的阅读。由于小编也是初次学习写技术文章，都是按照自己的理解来写的，可能会有错误的地方欢迎大家留言指出。文章中语言的组织也不是很好，希望大家理解。写这篇文章一是为了能让自己进一步理解Handler机制，并加强记忆。二是能和大家交流技术，共同进步。也希望能提起大家阅读源码的兴趣。最后，还是感谢大家阅读。
