我们先看下面例子
简单的Looper创建以及Handler的初始化如下：
Looper.prepare();
Handler mhandler = new Handler(Looper.myLooper()){
@Override
public void handleMessage(Message msg) {
int what = msg.what;
switch (what) {
case 0:
//do.
break;
//case others
default:
break;
}
}
};
Looper.loop();
mhandler.sendEmptyMessage(0);
1.初始化Looper：Looper.prepare()
2.初始化Handler
3.开启消息队列Looper.loop()
4.发送一个简单消息：mhandler.sendEmptyMessage(0);
下面我们将追踪每一步并分析其实现原理
1.创建Looper
Looper.prepare：
这个方法每个线程只能执行一次，这是怎么实现的呢？
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
以上代码可以看出来，prepare方法里面抛出一个异常，而sThreadLocal.get()又是什么呢，看下他的定义：
static final ThreadLocal sThreadLocal = new ThreadLocal();
原来是ThreadLoacl, 这是个Java什么类？我个人理解为是线程局部变量，好比为每个线程创建自己的变量，线程之间互不影响，这个类主要是起到线程隔离，就好比为每个线程都准备一个变量，这个变量类型就是<>里面的泛型
那么sThreadLocal就是为每个线程维护自己的Looper，哪个线程调用sThreadLocal.get()方法就是得到是自己的
调用sThreadLocal.get(),如果这个线程有了Looper，那么提示已经创建过Looper了，不可能重复创建，如果没有Looper，那么我可以使用 sThreadLocal.set(new Looper(quitAllowed))
让sThreadLocal来给当前线程维护一个Looper，这就保证了线程里面Looper的唯一性
那么Looper初始化做了哪些事情了呢？
new Looper()：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
构造函数里面只创建了一个MessageQueue和引用当前线程，这就准备好了Looper，那么MessageQueue是什么呢，如其名，是一个消息队列，我们经常听到消息队列，消息队列又是什么，其实就是一个队列，可以执行入队出队，其实就是将一个Message放入这个队列，需要的时候在队列最前面拿出最前面的一个Message，作为一个IT gay大伙都知道
2.初始化Handler
2.1Handler构造函数：
new Handler([Looper]):
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
参数1：Looper引用
参数2：回调接口，handlerMessage或者自己实现Handler内部方法handlerMessage，两者都可以
参数3：可能是关于消息是否需要同步的标志位
3.开启队列消息
Looper.loop()
final Looper me = myLooper();
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);
msg.recycleUnchecked();
}
以上是loop的内部几段重要实现
首先拿到消息队列，然后开始执行for死循环，调用queue.next()方法取出里面Message，如果消息是空，那么循环结束，否则执行msg.target.dispatchMessage，而dispatchMessage就是调用的Handler的handleMessage，那么消息的处理Handler便实现了。然后重置msg内部所有元素[注意在此之后引用的msg内部元素都是初始化的了，如果handleMessage中调用runOnUiThread取final类型的msg，那么runOnUiThread拿到的msg元素都是重置过的],下面就是追踪如何向队列MessageQueue里面放入消息和queue.next()到底怎么取出消息的
先看queue.next()如何实现
Message next(){
for (;;) {
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
}}}
}
摘取了一些关键代码，next()方法是取消息队列里面的Message的，有2种情况，第一种队列里面没有消息，那么是一个死循环，方法没有任何返回，第二种是队列里面有Message，那么会取出!isAsynchronous()的msg，这就是上面Handler初始化构造函数第三个参数来影响取出的msg，说明此时只会取异步的msg并返回，我们接着看下面的判断，判断当前时间和消息时间差，如果当前时间小于msg.when(消息需要出队的时间)，那么不做任何操作，等待下一次循环判断时间是否满足，这里我们可以猜测handler.postDelayed是不是就是给Msg预设一个出队时间，如果当前时间大于msg.when(消息需要出队的时间)，那么返回当前msg，并且将mMessages队列链表指向消息的下一个，即下一个消息就是队列头，之前的msg都会被弹出并且消费掉，这便是消息队列的next()取出方法
4.发送消息：
mhandler.sendEmptyMessage(0)分析：
sendEmptyMessageDelayed(what, 0);
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
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);
}
Message.obtain返回一个Message对象
方法追踪到低就是执行的是enqueueMessage方法，这个方法就是向MessageQueue里面放入Message，如下：
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;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
}
上面摘取的代码可以看出，这是一个队列的排序，按照when每个消息的时间进行排序，将每个消息按照时间最近越靠前来重新排序，或者说是将新的Message插入到一个时间由进到远已经排序好的队列中，变量mMessage是队列头，里面next指向下一个Message，这就形成了一个队列链表，队列里面每个元素有一个指针指向下一个元素，这就是Handler的sendMessage安排一个消息到消息队列里面，等待Looper的弹出并处理该消息
总结：
1.初始化Looper准备MessageQueue,[ThreadLocal的运用]
2.初始化Handler，引用MessageQueue与Thread
3.Looper.loop启动循环，不停查找MessageQueue队列里面消息并取出最近消息进行消费，回调handleMessage
4.Handler.sendMessage将生成的Message关联Handler并且按时间排序插入MessageQueue队列中，等待loop循环取出