虽然已经有那么多人写了，多个角度说不定哪句说到你点上了。
首先这是我理解的handler工作流程：
我分为四步：1，创建handler关联looper，2，获取消息，3，发送消息，4，处理消息
一，创建Handler并关联Looper
好的演讲总有个故事样的开头，例如有的演讲家会说，我先给大家讲个故事，或者今天早上我遇到了这样一件事什么什么的，我也给大家举个栗子吧：
<span style="font-family:FangSong_GB2312;font-size:14px;">public class MainActivity extends Activity {
private Handler handler1;
private Handler handler2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
handler1 = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
handler2 = new Handler();
}
}).start();
}
}</span>
<span style="font-family:FangSong_GB2312;font-size:14px;">new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
handler2 = new Handler();
}
}).start();</span>我们创建Handler时通常会调用Handler()方法，没有参数，它不干非要调用下面这个方法：
<span style="font-family:FangSong_GB2312;font-size:14px;">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;
}</span><span style="font-family:FangSong_GB2312;font-size:14px;"> public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}</span><span style="font-family:FangSong_GB2312;font-size:14px;"> 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));
}</span>
<span style="font-family:FangSong_GB2312;font-size:14px;"> private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}</span>但是有UI线程我们没有调用prepare方法，为什么呢。我们写java程序的时候熟悉的main入口方法还记得伐，就是public static void main(String[] args)，它也是android程序的入口，你在ActivityThread类里，这个方法里调用了Looper.prepareMainLooper()方法。
<span style="font-family:FangSong_GB2312;font-size:14px;">public static void main(String[] args) {
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}</span>而Looper.prepareMainLooper()方法调用了prepare方法new Looper去了，这样主线程就有了looper了，看下面。
<span style="font-family:FangSong_GB2312;font-size:14px;"> public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}</span> 而且上面的上面那段代码倒数第二句Looper.loop()就开始处理消息了。
<span style="font-family:FangSong_GB2312;font-size:14px;"> 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;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
msg.target.dispatchMessage(msg);
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "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.recycleUnchecked();
}
}</span>总结：1，自己new的线程要先调用prepare方法，它里面new出了looper，才能创建handler。
2，主线程不用调用prepare方法就能创建handler，主线程的main方法调用的prepareMainLooper里调用了prepare方法.
创建handler关联looper就讲完了。
二，获取消息
首先要说明的是官方不建议new一个Message再发送，而是用obtain方法从回收队列中取一个再用一次。为什么呢，其实想想也是，new一个对象就要开辟一块内存，初始化很多默认属性，如果有过时不用的一块内存为什么不用呢，如果说感觉它过时为什么不回收，一会儿new一会儿回收一会儿new一会儿回收太麻烦，不如放那儿算了，让回收队列引用着，别回收，需要的时候再拿来设好需要的属性接着用，所以不是你重新设定好的属性不要用，万一上一次设定的不是你要的呢。而且我觉得这种回收适合那种要很多很多的对象，而且每个生命周期不长。
其次，要是你直接new一个Message就发送了，就不要看这第二步了。
注意，这是Message的回收队列，不是某个线程要处理的消息队列。
发送消息时无论是调用Handler的obtainMessage方法还是Message的众多obtain方法，它最终都要调用Message.obtain()方法，其它操作都是对拿到的Message对象进行一些属性的赋值，所以获取Message的方法就看这个Message.obtain()方法。它的作用是从消息的回收队列中返回一个Message，我觉得要想知道怎么返回的，先知道怎么回收的比较好，也就是知道这个回收队列是怎么产生的比较好，还是先看上面代码里最后那句recycleUnchecked()方法吧。
<span style="font-family:FangSong_GB2312;font-size:14px;">void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}</span>哇，回收的时候人家已经把原来的值清空的，这巴掌，piapia嘎嘣脆
，好吧，不是你设定的值也能用了，先判空就行。
拿出纸笔，我们开始画图。
这个回收池叫sPool，它是个Message，而且还是静态的，刚开始它是空的，写上mPool,第一次来个消息，画个框，第一句next=sPool，sPool还空，第二句sPool=this,sPool里是新消息的地址，容量加。
又来一个废物Message,next=sPool,新的消息的next里存sPool的内容，即原来消息的地址，sPool=this,新消息的地址存到sPool中。
再来一个我就不画了，回收队列就是这样建好的，回来看obtain方法获取回收队列重新使用。
<span style="font-family:FangSong_GB2312;font-size:14px;"> 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();
}</span>获取消息就讲完了。
三，发送消息
不管你喜欢调用sendMessage(Message)还是sendEmptyMessage()还是post-runnable方法，最后都会调用sendMessageAtTime，post-runnable方法先从Message的回收队列里拿一个，再把runnable放进去，跟直接发message一样一样的。回到sendMessageAtTime,内容如下：
<span style="font-family:FangSong_GB2312;font-size:14px;"> 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);
}</span>
<span style="font-family:FangSong_GB2312;font-size:14px;"> private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}</span>"msg.target=this"把消息和handler关联了起来，一个消息只属于一个handler，然后我们看enqueueMessage方法：
<span style="font-family:FangSong_GB2312;font-size:14px;">boolean enqueueMessage(Message msg, long when) { if (msg.target == null) { throw new IllegalArgumentException("Message must have a target."); } if (msg.isInUse()) { throw new IllegalStateException(msg + " This message is already in use."); } synchronized (this) { if (mQuitting) { IllegalStateException e = new IllegalStateException( msg.target + " sending message to a Handler on a dead thread"); Log.w(TAG, e.getMessage(), e); msg.recycle(); return false; } msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake; 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; } </span>
这个方法，也是需要拿出纸笔画画的，最后的结果就是Handler中的消息队列按照时间when顺序排列，时间短的在前，最先被取出来。
这个方法最后返回true表示插入成功，中间返回false了就表示出错了。发送消息就这些了。
四，处理消息
最后一步，加油加油。
主线程里调用的loop方法不知道你还记不记得，它取出消息msg后就会执行msg.target.dispatchMessage(msg);方法，也就是处理方法。
msg的target是Handler,查看Handler的dispachMessage方法如下：
<span style="font-family:FangSong_GB2312;font-size:14px;"> public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}</span>
3570
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
