本文详细解析了Android中Handler的工作原理，包括消息发送、处理流程及其内部实现机制。
Handler的官方解释大致意思如下：
Handler是一种能够发送和处理与消息队列关联的Message和Runnable的一种对象。它隶属于调用Handler对象的线程，自它创建伊始，它就在当前线程发送消息到当前线程的消息队列，并且负责处理线程消息队列的消息。
Handler的用法主要有两种：其一，发送消息，其二，在另外一个线程处理消息。
对其一：
post(Runnable), postAtTime(Runnable, long), postDelayed(Runnable, long), sendEmptyMessage(int), sendMessage(Message), sendMessageAtTime(Message, long), and sendMessageDelayed(Message, long) 这些方法主要用来发送消息，其中，post version主要是发送Runnable，而sendMessage version则是用来发送消息，然后在handler的HandleMessage中处理。
如何处理的呢？最后一段非常关键：当我们创建了一个应用程序进程，它内部就开启了一个处理消息的Looper.
在new一个Handler的时候，
mLooper = Looper.myLooper();
public static final Looper myLooper() {
return (Looper)sThreadLocal.get();
}
mQueue = mLooper.mQueue;
mCallback = callback;
获取当前进程的Looper，然后获取它的消息队列，这样就将一个消息加入了消息队列，这个Looper开启类似下面，先运行Run方法，在Run方法中Looper.prepare,之后进入一个无限循环，Looper.loop(),在这里处理消息。在处理消息时调用callback，也就是HandleMessage或者Run开始处理。
因此，在用Handler的时候有两点需要注意：
一是callback函数，二时Post/sendMessage，callback为处理Message，而Post/sendMessage则是发送Message。
相关代码：
发送消息：
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)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
msg.target = this;
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}
可见发送消息就是将Message加入消息队列。
处理消息：
public static final void loop() {
Looper me = myLooper();
MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
while (true) {
Message msg = queue.next(); //获取下一个Message，可能会block
if (msg != null) {
if (msg.target == null) {
return;
}
msg.target.dispatchMessage(msg);
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf("Looper", "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycle();
}
}
也就是Loop循环不断从消息队列中获取消息进行处理：其实就是调用callback的过程。
Runnable处理流程：
现在来分析：发送流程：
Runnable runa = new Runnable() {
public void run() {
// TODO Auto-generated method stub
}
}
然后Handler mHandler = new Handler();
mHandler.post(runna);
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
官方解释是：Causes the Runnable r to be added to the message queue.也就是将Runnable加入到Message队列，怎么变成消息的呢？
接着往下看：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}----->
sendMessageDelayed(getPostMessage(r), 0)--->
------>
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
在上一步，决定何时发送，是否延时发送。
getPostMessage（）函数原型如下：
private final Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
在这里我们看到，Message.obtain()获取一个Message实例，然后将Runnable加入到Message的callback中，也就是封装成一个Message了。之后在大循环中进行处理。
到此，对于Handler发送Message也就很容易理解了，只不过把runnable改变成Message放到消息队列中去，然后就开始处理。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
