本来是不想写这篇文章的，但是很早以前看过的东西容易遗忘，希望还是给自己一个记录吧，另外此篇希望能够写的深入一些。
looper是什么就不介绍了吧，一个线程的消息泵，handler是消息的操作者，messagequeue是消息队列。
我们从源头开始看起，activity里的主ui线程就是ActivityThread mMainThread。这个ActivityThread的main函数会在程序创建的时候被调用，那么看下内部：
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
SamplingProfilerIntegration.start();
// CloseGuard defaults to true and can be quite spammy. We
// disable it here, but selectively enable it later (via
// StrictMode) on debug builds, but using DropBox, not logs.
CloseGuard.setEnabled(false);
Environment.initForCurrentUser();
// Set the reporter for event logging in libcore
EventLogger.setReporter(new EventLoggingReporter());
// Make sure TrustedCertificateStore looks in the right place for CA certificates
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
Process.setArgV0("<pre-initialized>");
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");
}首先走了Looper.prepareMainLooper();这个是与普通线程创建looper不同的地方，普通的都是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();
}
}还是prepare，但是传递的参数是false。在这里表示的是不允许退出。再来就是prepare:
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));
}存储线程本地对象中一个新的looper。同时可以看到，如果已经存在了这个线程本地对象，那么直接报错，也就是说一个线程只允许一个looper存在。
回到ActivityThread的main，初始化好之后就是sMainThreadHandler = thread.getHandler();这个getHandler里直接返回的是mH，其实就是一个Handler的子类H。这个H是个很长的类，就是定义好的对activity默认相应的各项。
这之后会调用到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;
// 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
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
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();
}
}首先看到在Looper的构造函数里就创建了MessageQueue:
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}那么这个loop函数中就直接取过来用，后面是个死循环，不断的通过queue.next()获取新的消息，并最终调用msg.target.dispatchMessage(msg);来处理。至此looper分析完了。下面看看Message的msg.target.dispatchMessage(msg);是怎么调用的：
看到message的时候，他的target就是Handler。这下子串上了吧，在looper的loop函数循环中枚举新message，并交给message里的Handler的dispatchMessage函数处理。那么好吧，我们回顾下，在发送message的时候，一般先obtain获取一个消息，我们看看：
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();
}看起来像链表是吧，每次取得时候将sPool给m，sPool移动到下一个，然后将sPoolSize减一，最后返回m。再看下回收部分：
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++;
}
}
}这里将自己赋值给sPool，然后sPoolSize++，看到这里应当明白，其实就是个链表的应用，保证sPool指向的是空闲的message的第一个。
然后呢，应用的时候会调用Handler的sendMessage函数，并且将参数设置为刚才获取到的空闲message，对吧。那么我们看看这个sendMessage，最终会调用到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);
}这里出现了MessageQueue，然后会走到enqueueMessage：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}第一句就是msg.target = this;，清楚了吧，这里将message的target赋值为handler自身。那么回到loop这个函数中，会走到msg.target.dispatchMessage(msg);这句话，实际上就是在走handler的msg.target.dispatchMessage。再进入到handler中看看这个dispatchMessage：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}能看到什么？先试图调用message的callback，如果没有则试图调用自身的mCallback的handleMessage，如果还没有，好吧，直接走handleMessage。依次看一下，首先是handleCallback：
private static void handleCallback(Message message) {
message.callback.run();
}这个callback是个什么呢？可以通过Message的obtain看到：
public static Message obtain(Handler h, Runnable callback) {
Message m = obtain();
m.target = h;
m.callback = callback;
return m;
}一个runnable，那么这个runnable是何时被赋值的呢？看Handler中：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}看到了吧，这里在执行post的时候给的runnable就是这个callback。那么再想想，我们在写代码的时候，很多时候都会走一个handler的post或者postDelayed，执行一段代码在主线程中，这个传递进来的runnable就是message的callback了。顺便说下，View里的post也是调用的这个东西。
下面是Handler自身的mCallback了，在构造Handler的时候可以指定一个callback传递进来，这个Callback是这样定义的：
public interface Callback {
public boolean handleMessage(Message msg);
}指定的话就会走这个标准的回调，否则最后会走Handler的handleMessage，这个才是我们最常用的继承下来的函数。看到了吧，由于loop函数运行在主线程中，因此以上这些都是在主线程中运行的代码。注意，这3个是排他性的，如果前面的可以执行就不会走后面的。
现在比较清楚了吧，整个消息循环是如何运转的。
java
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。