1、前言
- 在
Android中，Handler消息机制十分常见，在实现多线程消息切换的场景屡屡能看到，比如子线程切换到主线程更新UI操作、系统源码层也经常用到Handler消息机制，所以Handler显得格外的重要，开发者必学的一个知识点，不仅只会使用，还要深入源码了解其工作过程，正所谓“知其然，知其所以然”； - 通过本篇文章对
Handler机制进行一个详细的分析和解读，有什么不对的还望各位大佬指教；
2、了解Handler消息机制
1、为什么要使用Handler呢？在Android中，由于系统是默认不能在子线程对UI进行更新操作，那么就需要借助Handler机制进行消息异步切换，实际上就是为了避免线程操作不安全的问题，假如你没明白为什么子线程默认不能操作UI界面，可以看看这篇文章：Android：为什么子线程不能更新UI
-
Message：消息的载体； -
MessageQueue：消息队列，基于单链表的数据结构存放Message对象； -
Looper:消息泵，不断的从MessageQueue消息队列中抽取消息Message发送到Handler处理； -
Handler：消息的处理者；
那么我们就依次分析这四个组件涉及的源码以及工作原理
3、源码解析
要分析Handler消息机制工作原理，我们可以从Handler的创建为入口：
Handler Handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
实例化Handler，并且重写handleMessage方法，进入其内部观察：
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为空，会抛"Can't create handler inside thread that has not called Looper.prepare()"异常；进入Looper.myLooper()方法中查看：
//sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
可以看到，Looper对象是从ThreadLocal对象取出来的，简单来说一个线程对应一个ThreadLocal对象，一个ThreadLocal对象对应一个Looper，从而保证一个线程具有唯一的Looper对象，假如你不了解ThreadLocal，可以看看这篇文章Android：ThreadLocal源码解析
从源码的注释看出，要想Looper不为null，那么先调用prepare()方法来创建Looper对象，但是好像创建Handler的时候并没有调用啊？通过分析明白在主线程默认在程序入口main()方法已经执行创建Looper的操作了，那么我们转移到ActivityThread.main()中：
public static void main(String[] args) {
···
Looper.prepareMainLooper();
Looper.loop();
···
}
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));
}
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
可以看到在main方法中，调用了Looper.prepareMainLooper()，该方法再调用了Looper.prepare方法；
值得注意的是，系统在主线程才会默认调用
Looper.prepare方法，而在子线程必须手动调用，否则会报错；
在prepare方法中，实现了Looper的实例化，并且保存到ThreadLocal``对象中，以便下次直接获取； 在Looper的构造方法中可以看到实例化了MessageQueue消息队列，这样也就说明了MessageQueue对象在一个线程中是唯一的； 现在有了消息泵和消息队列那么就可以开始轮询了吧，回到main方法中调用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;
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
···
msg.target.dispatchMessage(msg);
}
}
可以看到先获取之前已经实例化的Looper对象，然后取出MessageQueue对象，然后开启一个for无限循环，调用next()获取消息体，假如没有消息就阻塞，有消息的话继续调用msg.target.dispatchMessage(msg)，实际上Message的target对象就是Handler，然后继续查看Handler的dispatchMessage():
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
public void handleMessage(Message msg) {
}
可以看到内部执行了handleMessage方法，该方法就是创建Handler时重写的方法，是个空实现，开发者可以在该方法处理消息；
那么知道了Handler、Looper、MessageQueue的创建和工作过程之后，不要忘了Message消息载体：
//Message message = new Message();
Message message = Message.obtain();
message.arg1 = 1;
message.obj = "AA";
handler.sendMessage(message);
/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*/
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
Message的创建推荐使用Message.obtain(),从源码可知直接从消息池中取，避免消息重复创建造成的资源浪费；消息创建好后，调用Handler.sendMessage()，我们继续查看该源码：
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
可以看到，通过一系列的方法，最终调用enqueueMessage方法，在该方法中可以看到msg.target = this，这句代码的意思就是把当前Handler赋值给msg.target变量中，也印证了之前说的，然后执行MessageQueue. enqueueMessage()，我们转移到该方法中：
boolean enqueueMessage(Message msg, long when) {
···
synchronized (this) {
···
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
该方法内部实现了按时间把消息插入队列中，采用单链表实现，提高插入、删除消息的效率；
通过以上的源码分析，现在再梳理一遍，
当Handler.sendMessage()发送消息，会通过MessageQueue.enqeueMessage()向消息队列添加一条消息；Looper.loop()开启消息轮询，并不断的调用MessageQueue.next()取出消息；通过Handler.dispatchMessage发送给Handler；Handler获取消息后调用Handler.handlerMessage()处理消息。
4、Handler.post(new Runnale)
其实在Handler消息机制中，还有一种发送消息的方式：
handler.post(new Runnable() {
@Override
public void run() {
}
});
现在让我们来看看它是一个怎样的流程：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
可以看到使用post方式发送消息，也是调用来sendMessageDelayed方法，只不过在getPostMessage方法中为Message.callback赋值来，可以猜想是为了回调使用的,通过上面的源码分析，会发现：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
在调用dispatchMessage方法的时候，是先优先判断Message.callback是否为空的，如果使用了post方式发送消息，那callback不为空，就会调用handleCallback方法,内部回调了run方法；
5、子线程使用Handler
既然主线程可以使用Handler，那么子线程一样可以；但是要注意的是，在创建Handler之前要调用Looper.prepare方法创建Looper对象,调用Looper.loop方法开启消息轮询，如以下代码：
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
Looper.loop();
}
}).start();
6、总结
- 通过对
Handler的源码分析，理清了Message、MessageQueue、Looper、Handler是在何时创建、何时建立关联、如何配合完成工作流程的； - 理清了
Handler.post方式发送消息的工作原理； - 子线程中使用
Handler的方法
