CrazyDailyQuestion
CrazyDailyQuestion copied to clipboard
MicroKibaco
2019-08-12: 说说你对Handler的理解(源码角度)?
Handler 是帮助我们从一个线程向主线程线程发消息的一个机制。
在创建 Handler 时会获取当前 Looper 如果不存在则会报错，就是说创建 Handler 一定要先有与之关联的 Looper，:Looper.perpare(),Looper.loop()
Looper.loop()会一直从 MessageQueue 中获取 Message 进行处理。
loop() 里调用了 MessageQueue.next()获取消息处理，并调用了 msg.target.dispatchMessage(msg) ，msg.target 就是发送该消息的 Handler，这样就回调到了 Handler 那边去了:
Looper:它在消息机制里是用来把普通线程转成looper线程的（Looper.prepare()），并担当消息循环的任务，当然，UI 线程是通过Looper.PrepareMainLoper()。 它会开启无限循环(Loper.loop())并不停的从 MessageQueue 中查看是否有新消息，如果有就拿出来处理，如果没有呢，就阻塞（其实真正的阻塞在 MessageQueue 的 next 里）。Loper在构造的时候会构建一个 MessageQueue 并持有它的引用。
MessageQueue: 消息队列，它用来插入（enqueueMessage），读取消息（next）。它虽然是个消息队列，但实际实现是个单链表，因为单链表在插入和读取上有优势。它插入是根据时间戳排序来的，根据时间戳的排序来指定next的下一条消息。而当next读取的时候，如果有消息，就取出来，如果没有，就阻塞。如果 next 取出来是 null，那么就表示整个app可以结束运行了。
Handler 的主要工作就是负责消息的发送和接收了。发送消息是 post 和 send 的一堆函数，其实到最后 enqueueMessage() 来进行入队，接收消息处理则是通过msg的next里返回的 looper 在交给 handler 的 dispatchMessage() 方法。Handler 在哪个线程之下构造就会持有当前这个线程的 looper 引用。Handler 工作的时候首先会判断 msg.callback（Runnable对象）是不是 null，不为 null 就会变为 handlerCallback（执行msg的callback），然后检查 mCallback 是不是 null，不为 null 执行 handlerMessage。而这个 mCallback 则又是通过 msg 的 target（对应的handler）来进行回调调用的。
一开始接触android的同学应该都知道，一般情况下android是不能在子线程中更新ui的。要更新ui界面的时候我们就需要用到android给我们提供的Handler机制。
Handler机制中核心的几个类有Handler、Looper、MessageQueen、Message这四个类，下面我们来一一剖析。
首先来谈谈Handler的用法（HOW）：
Handler中发送消息的函数可以分为两类：一类是post系列，一类则是sendMessage系列。
- post系列中包括如下方法：
post（Runnable）
postAtTime（Runnable， long）
postDelayed（Runnable， long）
方法的具体意义这里不做解释，不知道的朋友可以去查下文档。post方法是容许你排列一个Runnable的线程对象到主线程队列中，具体的实现我们待会儿再看。
sendMessage系列中包括的方法也大致和post中的差不多
sendEmptyMessage（int）
sendMessage（Message）
sendMessageAtTime（Message，long）；
sendMessageDelayed（Message， long）；
- Handler类的部分源码：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean postAtTime(Runnable r, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
如上是Handler中的post（Runnable）的方法，我们可以看到实际上是调用的Handler中的sendMessagexx系列的方法，所以这两种实际上是相同的。然后下面我们来看看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);
}
请大家看最后一行，我们可以看到sendMessageAtTime方法最后的结果enqueueMessage，enqueueMessage我想不用说看字面意思都应该很好理解就是一个将msg放入消息队列，也就是MessageQueue中，还有大家看到上面的一个判断queue==null，如果queue为null的画则会抛出错误，这也就是说我们在sendMessage方法之前必须先新建一个messageQueue，在Android中UI线程在启动时就给我们建立了一个MessageQueue，大家不信可以去看看相关源码，这里不多做解释，然后如果我们要在自己的子线程中用到拥有自己的Handler处理，则需要在子线程中维持一个该线程的MessageQueue，那么这个MessageQueue是怎样产生的呢，下面来看到Looper类，对就是Looper类：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
public static void prepare() {
prepare(true);
}
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对象的时候往往都会这样使用
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
Looper.loop();
}
}
上面是Looper类中的注释，介绍对Looper的使用，注意顺序 Looper.prepare(); XXX; Looper.loop()这样的顺序，仔细看前面prepare的函数通过调用此函数我们可以得到一个MessageQueue的对象，也就是说MessageQueue的对象是在这里产生的，所以Android给我们的使用示例会先调用prepare然后再是loop.
还有一点需要注意一个子线程最多只能有一个MessageQueue对象，如果你调用两次prepare则会产生Only one Looper may be created per thread的异常，我相信很多人应该都遇到过这个异常吧，反正本人初学Android之时是遇到过，后来解决了，只是不知道为什么会这样，这就是原因。
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
loop函数则是一个死循环不断的去取MessageQueue中的Message来，然后去执行里边的逻辑。那么还有一个很重要的问题没有解决，那就是当looper取到MessageQueue里边的Message之后，我们都知道这时候应该要执行我们的Handler类中的
handleMessage(Message msg) {
}
此方法了，最后由我们客户端去实现handleMessage的具体逻辑，对吧？那么问题是怎么来的，还有Looper取到的Message怎么知道应该执行哪一个handler的handleMessage方法呢？要知道我们可能在程序中声明很多个handler，那么我们接着往下看Message类
103 /*package*/ Handler target;
在Message类中的103行声明有一个target变量，对就是这个target！这个target变量存储的就是对这个消息是属于哪一个Handler的一个引用，也就是说这个消息需要哪个Handler来处理。就是它！这样就全部联系起来了是吧。
我们再次回过头去看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
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();
}
}
大家仔细看看上面的代码for(;;)里边的内容就是我上面所说的不断循环去读取Messagequeue中的Message当读取到其中一个Message后执行了这行代码：
msg.target.dispatchMessage(msg);
由上面的讲解我们知道msg.target是一个Handler对象这样我们就回到了我们Handler类的dispatchMessage方法，有人会问不对呀我们最后都是在HandlerMessage方法中处理的呀，先别捉急，心急可是吃不了热豆腐哦，我们来看这个dispatchMessage方法到底是何方神圣，好回到Handler类了：
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
这个函数很简单，大家看到没有这里有两种处理方法，第一种当msg.callback不为空则执行handleCallback，第二种当msg.callback为空的事后则执行了我们所熟悉的handlerMessage方法，我想第二种方式大家应该都知道，handleMessage大家应该都重写过这个方法。
那么来说说第一种，回到最开始，我们最初的起点就是这里，绕了一圈又回来来的！我们最开始的时候说了，Handler发送消息分为两个系列，虽然这两个系统在发送消息时都会调用同一个函数，但是在回调处理的时候还是略有不同。第一种就是post(Runnable)，我们都知道Runnable是一个线程，那么我们可以猜想handleCallback应该是执行我们线程里边的run方法，这样才合理嘛，回调回来。
那我们下面就看看是不是这样的
private static void handleCallback(Message message) {
message.callback.run();
}
看到没有我们的大Android系统果然没有让我们失望，就一句好执行回调的run方法。
最后回头来看我们handler发送消息的两种方式，分别对应上面说的两种回调方式，一目了然有木有！
handler.post(new Runnable() {
@Override
public void run() {
//anything what you can do
}
})
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
mHandler.sendMessage(msg）
开讲前,先思考以下几个问题:
1. 假如入我们要自己定制一个Handler,你会考虑怎么做?
2. 让你设计一个线程池，如果调用者在传入的Runnable任务时，在run方法直接使用了Handler，会发生什么?
3. IntentService里面也有一个Handler，它是如何结束执行呢，如果多次start这个IntentService，它又如何判断什么时候结束呢？
4. Android 子线程为什么不能访问UI? 一定不能访问UI吗?
了解这些问题我们首先需要了解Handler的本质,Handler实质是在指定线程中运行代码.下面就开始我们的Handler源码之旅吧~
一.ThreadLocal
Handler 的ThreadLocal 是给每一个线程都分配了内容,泛型里面分配了Thread对象.我们用Integer模拟一下ThreadLocal原理
运行以下example:
final ThreadLocal<Integer> mThreadLocal = new ThreadLocal<>();
mThreadLocal.set(1);
Log.e("ThreadLocalTest","thread0"+mThreadLocal+"");
new Thread("thread1"){
@Override
public void run() {
mThreadLocal.set(2);
Log.e("ThreadLocalTest","thread1"+mThreadLocal.get()+"");
}
}.start();
new Thread("thread2"){
@Override
public void run() {
Log.e("ThreadLocalTest","thread2"+mThreadLocal.get()+"");
}
}.start();
结果是:
ThreadLocalTest: thread0 1
ThreadLocalTest: thread1 2
ThreadLocalTest: thread3 null
显然,在不同的线程访问同一个ThreadLocal的get对象,结果却是不一样的.ThreadLocal有这样的结果,其实核心就是ThreadLocal内部会从各自的线程取一个数组.为什么ThreadLocal可以做到互不干扰呢?看一下set源码:
public void set(T value) {
Thread t = Thread.currentThread();
// 通过ThreadLocalMap 获取 当前线程的ThreadLocal
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
// 如果map为空就创建一个新的Map,存储当前线程的ThreadLocal
createMap(t, value);
}
我们再来看看 createMap 做了一件什么样的事情.
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
涉及复杂的存储算法,不细看了,只要知道,每次拿到一个新的 ThreadLocal 都会设置一个标志位就行了,保证对象唯一性.
我们再来看一下get的用法:
public T get() {
Thread t = Thread.currentThread();
// 通过getMap方法获取ThreadLocalMap数据, ThreadLocalMap里面存储了ThreadLocal,
ThreadLocalMap map = getMap(t);
if (map != null) {
// 不为空就返回这个对象的ThreadLocalMap.Entry value引用
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
// ThreadLocalMap 为空,由setInitialValue描述
return setInitialValue();
}
get的逻辑比较清晰,代码有相关注释.
二.MessageQueue
MessageQueue主要包含两个操作: 插入和读取对应的方法分别为 enqueueMessage 和 next,我们先来看看enqueueMessage 的源码:
/**
单例表插入:往消息队列插入一条消息,MessageQueue其实并不是用的队列,而是一个单例表结构.
*/
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) {
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
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;
prev.next = msg;
}
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
接下来,我们来看看 next方法:
Message next() {
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1;
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
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;
}
} else {
nextPollTimeoutMillis = -1;
}
if (mQuitting) {
dispose();
return null;
}
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null;
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
pendingIdleHandlerCount = 0;
nextPollTimeoutMillis = 0;
}
}
next方法也是单链表结构,因为单链表在插入和读取上有优势。它插入是根据时间戳排序来的，根据时间戳的排序来指定next的下一条消息。
而当next方法读取的时候，如果有消息，就取出来，如果没有，就阻塞。
如果 next 取出来是null，那么就表示整个app可以结束运行了。
三.Looper
Looper扮演着消息循环的角色,具体来说就是在不同的MessageQueue中查看是否有新的消息.
如果有新的消息就会立即处理,否则就一直堵塞在这里.首先,我们看一下相关的构造方法.在构造方法中会创建MessageQueue即消息队列,把当前线程的对象保存起来.
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
Handler工作中需要Looper,没有Looper的线程就会报错,那么如何为一个线程创建Looper呢,我写了一段示列代码如下:
new Thread("Looper"){
@Override
public void run() {
// Looper.prepare()即可为当前线程创建一个Looper
Looper.prepare();
Handler handler = new Handler();
// 通过Looper.loop()开启消息循环.
Looper.loop();
}
}.start();
Looper除了提供 prepare 方法外,还提供了 prepareMainLooper,这个方法主要是给主线程也就是ActivityThread创建Looper使用的,其本质也是通过prepare 实现的.
由于主线程的Looper比较特殊,所以Looper提供一个getMainLooper方法,通过它可以获取任意主线程的Looper.
prepare和prepareMainLooper的区别是:quit会直接退出Looper,而quitSafety只是设置一个退出标记.然后把所有消息队列已有的消息处理完毕安全退出.
Looper退出后,通过Handler发送消息会失败,这个时候Handler的send会返回false.在子线程中.
如果手动为其创建了Looper,那么所有的事情完成之后应该调用quit来终止循环,否则这个子线程就会一直处于等待状态,而如果退出Looper以后,这个线程就会终止,因此,建议不需要的时候终止Looper.
下面我们重点介绍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.");
}
// 当looper的quit方法被调用的时候,Looper就会调用MessageQunue的quit或quitSafety通知消息队列退出
final MessageQueue queue = me.mQueue;
// 当消息队列标记为退出状态,next就会标记为null,也就是Looper必须退出,否则Looper会一直无限循环下去.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
// loop方法是个死循环
for (;;) {
// 可能会被阻塞
Message msg = queue.next();
// 唯一跳出这个方法的是 queue.next 返回为null
if (msg == null) {
// loop会调用 MessageQueue 的 next 方法获取新的信息,looper会处理这条信息.
return;
}
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
// msg.target.dispatchMessage(msg),这里的 msg.target 是发送这条消息的handeler对象
msg.target.dispatchMessage(msg);
// handler对象最终又交给disPatchMessage处理了
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
// 不同的是,Handler所使用的dispatchMessage方法是在创建Handler时使用的Looper执行的.这样就造成将代码切换到指定线程中执行了
if (slowDispatchThresholdMs > 0) {
final long time = end - start;
if (time > slowDispatchThresholdMs) {
Slog.w(TAG, "Dispatch took " + time + "ms on "
+ Thread.currentThread().getName() + ", h=" +
msg.target + " cb=" + msg.callback + " msg=" + msg.what);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
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();
}
}
四.How does Handler Work ?
时间关系,周末总结~
五.Main Thread Message Loop
时间关系,周末总结~
六.Conclusion
说了这么多,看别人的东西始终是别人的,我们不如简单的用Thread实现一下Handler吧,帮助大家更好的理解Handler的运行流程
private Handler mThread = new Handler();
@Override
public void runTest() {
mThread.looper.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
mThread.looper.setTask(new Runnable() {
@Override
public void run() {
System.out.println("Welcome to join us!CrazyDailyQuestion~~~");
}
});
mThread.looper.quit();
}
class Looper extends Thread {
private Runnable task;
private boolean quit;
synchronized void setTask(Runnable task) {
this.task = task;
}
synchronized void quit() {
quit = true;
}
@Override
public void run() {
while (quit) {
synchronized (this) {
if (task != null) {
task.run();
task = null;
}
}
}
}
}
class Handler {
Looper looper = new Looper();
}
以上代码基本就是Handler简易版本,可能有bug,不过看懂我上面写的,再去理解Handler源码会轻松很多.如果大家对本文存在疑惑,欢迎到每日一问留言.
Handler用于封装消息的发送，先介绍与Handler相关的几个元素：
一、Message：消息,Handler接收和处理的消息对象;
二、Looper：一个消息轮询机制，每个线程只能拥有一个Looper.它的loop方法负责读取MessageQueue中的消息,读到消息之后就把消息发送该消息的Handler处理.
三、MessageQueue:消息队列.
Handler内部会跟Looper进行关联,也就是说在Handler内部可以找到Looper,找到Looper也就找到了MessageQueue,在handler中发送消息,就是向MessageQueue队列中发送消息.
下面讲一下具体细节:
默认整个应用程序都是通过ActivityThread创建,在ActivityThread中创建Activity,默认创建main线程,在线程中默认创建Looper;在Activity的main方法中,调用Looper.prepareMainLooper(), 在prepareMainLooper()中调用prepared(),调用ThreadLocal.set(new Looper()), 传入了一个Looper对象, 在new Looper()这个构造方法中, 先new 出一个MessageQueue(), 并将当前执行的线程对象赋值给Handler的Thread对象.
Handler和Looper的MessageQueue关联: 通过刚才的代码, 在Handler中调用Looper.myLooper(), 通过ThreadLocal.get(), 拿到Looper对象, 再通过该对象拿到MessageQueue. 通过for循环轮询队列, 找到消息的话, 通过msg.target.dispatchmessage(msg), 也就是Handler.dispatchMessage方法, 该方法首先会调用callback的handleMessage(), 如果这个方法执行返回true, 则代表该callback消费了该消息事件, Handler的handleMessage()将不会执行.
....搞了半天，鼠标移动，全部没了。 因为Android常用到的就是主线程创建Handler，然后子线程使用这个Handler对象发送消息给子线程。我就来梳理；一下这个吧，比较简单。 主要的步骤：主线程创建Handler，获取到looper中的消息队列；子线程中使用Handler穿件消息，并调用sendMessage方法将消息放到消息队列中；主线程的mainLooper早在进程创建的时候，程序的入口main方法中就已经创建了，调用looper的loop方法遍历消息队列，然后通过Handler的handleMessage方法回调到主线程中。 1.创建Handler，并得到消息队列MessageQueue
public Handler(Callback callback, boolean async) {
mLooper = Looper.myLooper();
mQueue = mLooper.mQueue;
}
2.消息的创建，并放到消息队列中 消息的创建就先忽略，直接一路跟踪sendMessage方法，看到enqueueMessage()方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//这一步是将handler放到msg中，做个标记，类似于四代目火影的飞雷神标记
msg.target = this;
//这一步就是将消息存放到消息队列中
return queue.enqueueMessage(msg, uptimeMillis);
}
3.看一下主线程的looper的创建，以及looper的工作原理
class ActivityThread{
public static void main(String[] args) {
//在程序的入口就创建了mainLopper对象，并执行了loop方法，循环遍历消息队列
Looper.prepareMainLooper();
Looper.loop();
}
}
class Looper{
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));
}
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
sMainLooper = myLooper();
}
}
public static void loop() {
final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
for (;;) {
//构建一个死循环，然后遍历消息队列
Message msg = queue.next(); // might block
try {
//刚才的飞雷神标记起作用了，这里获取到msg里的handler对象，然后执行dispatchMessage方法
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
}
}
}
5.最后我们看下dispatchMessage()方法的执行
public void dispatchMessage(Message msg) {
handleMessage(msg);
}
总结一下：跨线程传递消息，背后必将又一个死循环在遍历或者是一直等待消息。主线程中的handler机制比较简单，在程序入口就创建了无限循环方法loop()，如果有子线程发消息到队列中，loop中的死循环就会遍历队列并获取这个消息，然后将消息回调给主线程。
Android的Handler可以指定在某个运行中的线程中执行代码，一般我们会在子线程中做一些耗时操作，然后再借助Handler切换到主线程更新UI。Handler具备这种特性跟Looper、MessageQueue有密不可分的关系。
Handler的工作流程：
- Handler发送消息
handler.sendMessage(msg)，这条message会记录发送的handler为target - sendMessage会调用到与Handler关联的Looper中的
messageQueue.enqueueMessage() - enqueueMessage()就是向将message插入到MessageQueue中
- 线程开始执行时，就会启动绑定的Looper，
Looper.loop()让Looper一直循环地从内部的MessageQueue.next()方法中取Message。 -
MessageQueue.next()如果取到了Message就返回给Looper，Looper再把message交由message.target（即发送这条message的handler）去处理，如果当前没有消息，Looper就会阻塞，当前线程也会释放掉CPU进入休眠状态，直到有新消息来才被唤醒。 - 最终调用到
handler.dispatchMessage()中处理消息，dispatchMessage()方法是在创建Handler时所使用的Looper中执行的，这样就成功地将代码逻辑切换到指定的线程中去执行了。
Looper在哪个线程创建的，loop()就运行在哪个线程中，同样dispatchMessage()也是在这个线程执行。mainLooper是在 Android的主线程ActivityThread的main方法中调用Looper.prepareMainLooper()中初始化的，所以mainLooper是运行在主线程中的。而Handler的默认Looper就是mainLooper，所以能很方便地用Handler切换到主线程。
hadler的实现其实是个很复杂的问题（对我这个小白来说），不仅涉及到java相关的实现，Android为了保证消息机制在底层也可以使用，相关实现其实是放在native当中的，java层中的Looper对象持有一个nativeMessageQueue的指针引用mPtr，通过这个指针来调用native层的方法。
从设计的角度考虑，Android应该是“消息驱动”的，也就是主线程的UI更新都是依赖于消息的收发的。要实现“消息驱动”，首先要有一个消息队列来对消息进行维护，其次要对消息进行初始化和消息循环。
具体到Android实现当中，消息循环是用Looper来维护的，主线程的Looper对象是其他线程共享的，其他线程的Looper都存在各自的线程本地变量(ThreadLocal)当中；Lopper中持有的MessageQueue对象是消息队列的具体实现，Looper.loop()方法会对消息队列进行循环读取，MessageQueue.next方法会从消息队列中循环取消息（这个操作是用加锁的方式来实现的线程安全），此时消息创建和消息循环的流程就都有了。
还剩最后一部分就是消息发送。现在我们可以在主线程中，用mainLooper来循环读取消息，那其他线程也还需要往这个消息队列中插入消息。Android中的消息发送是用Handler来实现的。Handler负责为发送消息和接收提供接口。这一块还没有深入了解，待补充。
