每个线程持有一个ThreadLocalMap对象，而ThreadLocalMap中包含了一个ThreadLocal<Looper>对象，ThreadLocal对象中存储了Looper对象，而Looper对象里又包含了MessageQueue队列，MessageQueue里是Message对象。Message对象的target属性指向了Handler对象。然后Handler在初始化的时候会通过当前线程的Looper获得一个MessageQueque。
可以看到Handler默认通过Looper获取了当前线程的MessageQueue
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; }通过post或sendMessageDelayed或sendMessage或post提交的消息最终都会调用handler的sendMessageAtTime方法，方法的第二个参数是由SystemClock.uptimeMillis()+延迟的毫秒数组成，方法最后调用了enqueueMessage方法将消息放入队列 SystemClock.uptimeMillis()表示系统开机到当前的时间总数，单位是毫秒
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); }在enqueueMessage中，我们看到它将消息的target指向当前Handler对象，然后调用了MessageQueue的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对象有个next字段保存列表中的下一个，MessageQueue中的mMessages保存链表的第一个元素。 这里看MessageQueue的enqueueMessage方法，当队列没有元素或消息的执行时间小于链表头部元素的执行时间，消息直接被插入到头部,否则按时间先后插入到队列中
boolean enqueueMessage(Message msg, long when) { ... 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; } ... } return true; }Message的接收可以从Lopper的loop方法看起，loop方法是一个死循环，它不断从当前线程的消息队列中取出消息调用MessageQueue的next方法， 并且执行消息对应Handler的dispatchMessage(msg)方法。
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 ... try { msg.target.dispatchMessage(msg); end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis(); } ... }再看看Handler的dispatchMesage方法,这里的msg.callback是通过post方法提交的Runnable，如果是post方法提交的就会执行Runnable的run方法，如果没有设置callback就会调用我们重写的handleMessage方法。
public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } handleMessage(msg); } }至此Message的发送和接收都清楚了
