handler之知识分类
1、handler的原理是什么 ？
1）、Handler封装了消息的发送，(主要包括消息发送给谁)
Looper---消息封装的载体
1.内部包含一个消息队列就是MessageQueue，所有的Handler发送的消息都走这个消息队列。
2.Looper.Loop()方法，就是一个for死循环，不断的从MessageQueue取消息，如有有消息就处理消息，没有消息就阻塞
2）、MessageQueue,就是一个消息队列，可以添加消息，并处理消息
3）、Handler也很简单， 在构造Handler时候内部会跟Looper 进行关联， 通过 Looper.myLooper() 获取到
Looper。找到Looper也就找到了MessageQueue。在Handler中发送消息，
其实就是向MessageQueue队列中发送消息
总结：handler负责发送消息，Looper负责接收Handler 发送的消息，并直接把消息回传给Handler自己，MessageQueue就是一个存储消息的容器。
在子线程中通过Handler发送消息，该消息会在Hanlder中的handleMessage()中被解析，并进行相对应的UI组件更新
Android消息机制的相关概念
1、相关概念的解释
主线程（UI线程）
定义：当程序第一次启动时，Android会同时启动一条主线程（Main Thread）
作用：主线程主要负责处理与UI相关的事件
Message（消息）
定义：Handler接收和处理的消息对象（Bean对象）
作用：通信时相关信息的存放和传递
Message Queue（消息队列）
定义：采用单链表的数据结构来存储消息列表
作用：用来存放通过Handler发过来的Message，按照先进先出执行
Handler（处理者）
定义：Message的主要处理者
作用：负责发送Message到消息队列&处理Looper分派过来的Message
Looper（循环器）
定义：扮演Message Queue和Handler之间桥梁的角色
作用：
消息循环：循环取出Message Queue的Message
消息派发：将取出的Message交付给相应的Handler
ThreadLocal
定义：线程内部的数据存储类
作用：负责存储和获取本线程的Looper
2、文字解读它们之间的关系
Looper中存放有MessageQueen，MessageQueen中又有很多Message，当我们的Handler发送消息的时候，会获取当前的Looper，并在当前的Looper的MessageQueen当中存放我们发送的消息，而我们的MessageQueen也会在Looper的带动下，一直循环的读取Message信息，并将Message信息发送给Handler，并执行HandlerMessage()方法
其实这是一个循环的过程，读懂这句话和看懂图解很重要，会给我们下面的源码分析带来很大的帮助。
三.Android消息机制的通信流程?
1.Looper源码分析
2、Looper.prepareMainLooper()
//在主线程中初始化Looper
public static void prepareMainLooper() {
//在这里会调用prepare(boolean quitAllowed)方法
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
//看下prepare(boolean quitAllowed)方法
private static void prepare(boolean quitAllowed) {
//判断sThreadLocal是否为null，否则抛出异常
//即Looper.prepare()方法不能被调用两次。也就是说，一个线程中只能对应一个Looper实例
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//初始化Looper对象设置到ThreadLocal中
sThreadLocal.set(new Looper(quitAllowed));
}
//看下Looper的构造方法
private Looper(boolean quitAllowed) {
//创建了一个MessageQueue（消息队列）
//这说明，当创建一个Looper实例时，会自动创建一个与之配对的MessageQueue（消息队列）
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
整个Looper的初始化准备工作就完了，这里做了哪几件事：
Looper的创建会关联一个MessageQueen的创建
Looper对象只能被创建一次
Looper对象创建后被存放在sThreadLocal中
3、Looper.loop()
public static void loop() {
//myLooper()方法作用是返回sThreadLocal存储的Looper实例，如果me为null，loop()则抛出异常
//也就是说loop方法的执行必须在prepare方法之后运行
//也就是说，消息循环必须要先在线程当中创建Looper实例
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//获取looper实例中的mQueue（消息队列）
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
//进入消息循环
for (;;) {
//next()方法用于取出消息队列里的消息
//如果取出的消息为空，则线程阻塞
Message msg = queue.next();
if (msg == null) {
return;
}
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.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
//消息派发：把消息派发给msg的target属性，然后用dispatchMessage方法去处理
//Msg的target其实就是handler对象，下面会继续分析
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
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();
}
}
整个Looper的循环过程就完了，这里做了哪几件事：
取出Looper和MessageQueen
进入消息循环，有消息则分发出去
消息资源的回收
4、Looper的退出。当然Looper也提供两个方法可以退出一个Looper：
quit()：quit会直接退出Looper
quitSafety()：quitSafety只是设定一个退出标记，然后把消息队列中的已有消息处理完毕后退出Looper
5.MessageQueen源码分析:
5.1、由于MessageQueen是用来存放Message的，那么是如何存储Message的呢？
由于Handler使用Post()方法将Message传递到MessageQueen中，在MessageQueen中会使用enqueueMessage()方法存储Message，其实现的方式是通过单链表的数据结构来存储消息列表
boolean enqueueMessage(Message msg, long when) {
...
synchronized (this) {
...
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;
}
整个进队列的过程就完了，这里做了哪几件事：
首先判断消息队列里有没有消息，没有的话则将当前插入的消息作为队头，并且这时消息队列如果处于等待状态的话则将其唤醒
若是在中间插入，则根据Message创建的时间进行插入
5.2、既然MessageQueen存了消息之后，是如何提供取出来的方法的呢？
存消息是Handler存进来的，那么取消息就应该是Looper中取了，从Looper的源码可以看出，消息就是在Looper中取出的，其实现是用MessageQueen里面的next()方法
Message next() {
......
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
// nativePollOnce方法在native层，若是nextPollTimeoutMillis为-1，这时候消息队列处于等待状态。
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，下次循环消息队列则处于等待状态
nextPollTimeoutMillis = -1;
}
//退出消息队列，返回null，这时候Looper中的消息循环也会终止。
if (mQuitting) {
dispose();
return null;
}
......
}
.....
}
}
5.3、在MessageQueen存消息的媒介当然是通过Message对象啦，那这个Message对象又是什么呢？
其实这个Message就是用来存储Message中各种信息的Bean对象，从源码中可以其属性，这里例举我们常用的几个
public int what;
public int arg1;
public int arg2;
public Object obj;
public Messenger replyTo;
int flags;
long when;
Bundle data;
Handler target;
Runnable callback;
二.handler源码分析2
1、Handler的创建
Handler的创建会关联一个Looper对象，而Looper对象是关联着MessageQueen对象，所以在Handler创建时候，取出Looper和MessageQueen
public Handler(Callback callback, boolean async) {
...
//取出Looper
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//取出Looper中的MessageQueen
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
前面我们也说过了Looper是存放在ThreadLocal里面的，可以看到下面的源码就知道了
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
整个创建的过程就完了，这里做了哪几件事：
取出Looper
取出Looper中的MessageQueen
2、Handler发送消息
1、方式一：sendMessage(Message msg)
public final boolean sendEmptyMessage(int what){
return 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
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);
}
//调用sendMessage方法其实最后是调用了enqueueMessage方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//为msg.target赋值为this，也就是把当前的handler作为msg的target属性
//如果大家还记得Looper的loop()方法会取出每个msg然后执行msg.target.dispatchMessage(msg)去处理消息，其实就是派发给相应的Handler
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//最终调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会保存到消息队列中去
return queue.enqueueMessage(msg, uptimeMillis);
}
2、方式二：post(Ruunable r)
public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r), 0);
}
其实post()方法最终也会保存到消息队列中去，和上面不同的是它传进来的一个Runnable对象，执行了getPostMessage()方法，我们往下追踪
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
实质上就是将这个Runnable保存在Message的变量中，这就导致了我们下面处理消息的时候有两种不同方案
3、Handler处理消息
你还记得前面所说Looper中msg.target.dispatchMessage()方法吗？这个方法就是调用Handler的dispatchMessage()
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
//1. post()方法的处理方法
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//2. sendMessage()方法的处理方法
handleMessage(msg);
}
}
//1. post()方法的最终处理方法
private static void handleCallback(Message message) {
message.callback.run();
}
//2. sendMessage()方法的最终处理方法
public void handleMessage(Message msg) {
}
整个处理的过程就完了，这里做了哪几件事：
post()方法的处理方法就是将传进来的Runnable执行run()方法
sendMessage()方法的处理方法就是执行handleMessage()空方法，这也是我们为什么要在Handler重写这个方法的原因
一.handler的源码解析？
1、Looper的prepare()和loop()两个方法。
public static final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(true));
}
sThreadLocal是一个ThreadLocal对象，可以在一个线程中存储变量。
可以看到，在第5行，将一个Looper的实例放入了ThreadLocal，并且2-4行判断了sThreadLocal是否为null，否则抛出异常。
这也就说明了Looper.prepare()方法不能被调用两次，同时也保证了一个线程中只有一个Looper实例~相信有些哥们一定遇到这个错误。
下面看Looper的构造方法：在构造方法中，创建了一个MessageQueue（消息队列）。
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mRun = true;
mThread = Thread.currentThread();
}
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);
}
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.recycle();
}
}
第2行：
public static Looper myLooper() {
return sThreadLocal.get();
}方法直接返回了sThreadLocal存储的Looper实例，如果me为null则抛出异常，也就是说looper方法必须在prepare方法之后运行。
第6行：拿到该looper实例中的mQueue（消息队列）
13到45行：就进入了我们所说的无限循环。14行：取出一条消息，如果没有消息则阻塞。
27行：使用调用 msg.target.dispatchMessage(msg);把消息交给msg的target的dispatchMessage方法去处理。
Msg的target是什么呢？其实就是handler对象，下面会进行分析。44行：释放消息占据的资源。
好了，我们的异步消息处理线程已经有了消息队列（MessageQueue），也有了在无限循环体中取出消息的哥们，现在缺的就是发送消息的对象了，
于是乎：Handler登场了。
2、Handler
使用Handler之前，我们都是初始化一个实例，比如用于更新UI线程，我们会在声明的时候直接初始化，或者在onCreate中初始化Handler实例。
所以我们首先看Handler的构造方法，看其如何与MessageQueue联系上的，它在子线程中发送的消息（一般发送消息都在非UI线程）怎么发送到MessageQueue中的。
public Handler() {
this(null, false);
}
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;
}
14行：通过Looper.myLooper()获取了当前线程保存的Looper实例，
然后在19行又获取了这个Looper实例中保存的MessageQueue（消息队列），
这样就保证了handler的实例与我们Looper实例中MessageQueue关联上了。然后看我们最常用的sendMessage方法
public final boolean sendMessage(Message msg) {
return sendMessageDelayed(msg, 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);
}
辗转反则最后调用了sendMessageAtTime，在此方法内部有直接获取MessageQueue然后调用了enqueueMessage方法.
我们再来看看此方法：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
enqueueMessage中首先为meg.target赋值为this，
【如果大家还记得Looper的loop方法会取出每个msg然后交给msg.target.dispatchMessage(msg)去处理消息】，也就是把当前的handler作为msg的target属性。最终会调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会保存到消息队列中去。
现在已经很清楚了Looper会调用prepare()和loop()方法，
在当前执行的线程中保存一个Looper实例，这个实例会保存一个MessageQueue对象，然后当前线程进入一个无限循环中去，不断从MessageQueue中读取Handler发来的消息。然后再回调创建这个消息的handler中的dispathMessage方法，这个方法：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
可以看到，第10行，调用了handleMessage方法，下面我们去看这个方法：
public void handleMessage(Message msg) {
}
可以看到这是一个空方法，为什么呢，因为消息的最终回调是由我们控制的，我们在创建handler的时候都是复写handleMessage方法，
然后根据msg.what进行消息处理。
例如：
private Handler mHandler = new Handler()
{
public void handleMessage(android.os.Message msg)
{
switch (msg.what)
{
case value:
break;
default:
break;
}
};
};
3、Handler post,今天有人问我，Handler的post方法创建的线程和UI线程有什么关系？
其实这个问题也是出现这篇博客的原因之一；：
mHandler.post(new Runnable()
{
@Override
public void run() {
Log.e("TAG", Thread.currentThread().getName());
mTxt.setText("yoxi");
}
});
然后run方法中可以写更新UI的代码，其实这个Runnable并没有创建什么线程，而是发送了一条消息，下面看源码：
public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
可以看到，在getPostMessage中，得到了一个Message对象，然后将我们创建的Runable对象作为callback属性，赋值给了此message.
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);
}
最终和handler.sendMessage一样，调用了sendMessageAtTime，然后调用了enqueueMessage方法，给msg.target赋值为handler，最终加入MessagQueue。可以看到，这里msg的callback和target都有值，那么会执行哪个呢？
其实上面已经贴过代码，就是dispatchMessage方法：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
第2行，如果不为null，则执行callback回调，也就是我们的Runnable对象。
一. Handler的源码分析----
说到Android的消息机制，
Handler是Android消息机制的上层接口，因此在开发过程中也只需要和Handler交互即可，
很多人认为Handler的作用就是更新UI,这也确实没错，但除了更新UI，Handler其实还有很多其他用途，比如我们需要在子线程进行耗时的I/O操作，可能是读取某些文件或者去访问网络等，当耗时操作完成后我们可能需要在UI上做出相应的改变。
但由于Android系统的限制，我们是不能在子线程更新UI控件的，否则就会报异常， 可以通过Handler切换到主线程中执行UI更新操作。
上面的例子其实就是Handler的基本使用，在主线中创建了一个Handler对象，然后通过在子线程中模拟一个耗时操作完成后通过sendEmptyMessage(int)方法发送一个消息通知主线程的Handler去执行相应的操作。
通过运行结果我们也可以知道Handler确实也是在主线程运行的。
那么问题来了，通过Handler发送的消息是怎么到达主线程的呢？
Message:Handler接收和处理消息的对象。
Looper:每个线程只能有一个Looper。它的loop方法负责读取MessageQueue中的消息，读到消息后把消息发送给Handler进行处理。
MessageQueue：消息队列，它采用先进先出的方式来管理Message。程序创建Looper对象时，会在它的构造方法中创建MessageQueue对象。
Handler:它的作用有两个—发送消息和处理消息，程序使用Handler发送消息，由Handler发送的消息必须被送到指定的MessageQueue;否则消息就没有在MessageQueue进行保存了。
而MessageQueue是由Looper负责管理的，也就是说，如果希望Handler正常工作的话，就必须在当前线程中有一个Looper对象。
最后小总结：
Android中的Looper类主要作用是来封装消息循环和消息队列的，用于在android线程中进行消息处理。handler是用来向消息队列中插入消息的并最好对消息进行处理。
(1) Looper类主要是为每个线程开启的单独的消息循环。 默认情况下android中新诞生的线程是没有开启消息循环的。（主线程除外，主线程系统会自动为其创建Looper对象，开启消息循环） Looper对象负责管理MessageQueue，而MessageQueue主要是用来存放handler发送的消息，而且一个线程只能有一个Looper，对应一个MessageQueue。
(2)通过Handler对象来与Looper进行交互的。Handler可看做是Looper的一个接口，用来向指定的Looper中的MessageQueue发送消息并且Handler还必须定义自己的处理方法。 默认情况下Handler会与其被定义时所在线程的Looper绑定，如Handler在主线程中定义，它是与主线程的Looper绑定。
mainHandler = new Handler() 等价于 new Handler（Looper.myLooper()）
Looper.myLooper()：获取当前进程的looper对象，
Looper.getMainLooper() 用于获取主线程的Looper对象。
(3) 在非主线程中直接new Handler() 会报如下的错误: Can't create handler inside thread that has not called Looper.prepare()
原因是非主线程中默认没有创建Looper对象，需要先调用Looper.prepare()启用Looper，然后再调用Looper.loop()。
(4) Looper.loop():启动looper中的循环线程，Handler就会从消息队列里取消息并进行对应处理。 最后要注意的是写在Looper.loop()之后的代码不会被执行，这个函数内部应该是一个循环，当调用mHandler.getLooper().quit()后，loop()才会中止，其后的代码才能得以运行。
先来看看Handler的构造方法源码：
public class Handler {
//未实现的空方法handleMessage（）
public void handleMessage(Message msg) {}
// 通常用于创建Handler的构造方法之一
public Handler() {
this(null, false);
}
// 构造方法的内调用的this(null, false)的具体实现
public Handler(Callback callback, boolean async) {
//检查Handler是否是static的，如果不是的，那么有可能导致内存泄露
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());
}
}
//重要组件出现啦！Looper先理解成一个消息队列的管理者，用来从消息队列中取消息的，后续详细分析
mLooper = Looper.myLooper();
if (mLooper == null) {
//这个异常很熟悉吧，Handler是必须在有Looper的线程上执行，这个也就是为什么我在HandlerThread中初始化Handler
//而没有在Thread里面初始化，如果在Thread里面初始化需要先调用Looper.prepare方法
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//将mLooper里面的消息队列复制到自身的mQueue,这也就意味着Handler和Looper是公用一个消息队列
mQueue = mLooper.mQueue;
//回调函数默认是Null
mCallback = null;
}
分析：Handler的构造方法源码不是很多，也比较简单，但从源码可知，
在创建Handler时，Handler内部会去创建一个Looper对象，这个Looper对象是通过Looper.myLooper()创建(后续会分析这个方法)，同时还会创建一个MessageQueue，而这个MessageQueue是从Looper中获取的，这意味Handler和Looper共用一个消息队列，当然此时Handler,Looper以及MessageQueue已经捆绑到一起了。
上面还有一个情况要说明的，那就是:
if (mLooper == null) {
//这个异常很熟悉吧，Handler是必须在有Looper的线程上执行，这个也就是为什么我在HandlerThread中初始化Handler
//而没有在Thread里面初始化，如果在Thread里面初始化需要先调用Looper.prepare方法
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()"); }
这里先回去判断Looper是否为空，如果为null，那么就会报错，这个错误对我们来说应该比较熟悉吧，那为什么会报这个错误呢？
在前面说过Handler的作用有两个—发送消息和处理消息，我们在使用Handler发送消息，由Handler发送的消息必须被送到指定的MessageQueue;否则就无法进行消息循环。而MessageQueue是由Looper负责管理的，
也就是说，如果希望Handler正常工作的话，就必须在当前线程中有一个Looper对象。那么又该如何保障当前线程中一定有Looper对象呢？
这里其实分两种情况：
（1）在主UI线程中，系统已经初始化好了一个Looper对象，因此我们可以直接创建Handler并使用即可。
（2）在子线程中，就必须自己手动去创建一个Looper对象，并且去启动它，才可以使用Handler进行消息发送与处理。
class childThread extends Thread{
public Handler mHandler;
@Override
public void run() {
//子线程中必须先创建Looper
Looper.prepare();
mHandler =new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
//启动looper循环
Looper.loop();
}
}
2) 分析完Handler的构造方法，我们接着看看通过Handler发送的消息到底是发送到哪里了？先来看看Handler的几个主要方法源码：
// 发送一个空消息的方法，实际上添加到MessagerQueue队列中
public final boolean sendEmptyMessage(int what) {
return 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);
}
// 最后调用此方法添加到消息队列中
private boolean enqueueMessage(MessageQueue queue, Message msg,long uptimeMillis) {
msg.target = this;// 设置发送目标对象是Handler本身
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);// 添加到消息队列中
}
// 在looper类中的loop（）方法内部调用的方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
分析：通过源码可知，当我们调用sendEmptyMessage(int)发送消息后。最终Handler内部会去调用enqueueMessage(MessageQueue queue,Message msg)方法把发送的消息添加到消息队列MessageQueue中，
同时还有设置msg.target=this此时就把当前handler对象绑定到msg.target中了，这样就完成了Handler向消息队列存放消息的过程。
这个还有一个要注意的方法 dispatchMessage(Message),这个方法最终会在looper中被调用(这里先知道这点就行，后续还会分析)。
3.MessageQueue消息队列？
其实在Android中的消息队列指的也是MessageQueue，MessageQueue主要包含了两种操作，插入和读取，而读取操作本身也会伴随着删除操作，插入和读取对应的分别是enqueueMessage和next，
其中enqueueMessage是向消息队列中插入一条消息，而next的作用则是从消息队列中取出一条消息并将其从队列中删除。虽然我们一直称其为消息队列但是它的内部实现并不是队列，而是通过一个单链表的数据结构来维护消息列表的，因为我们知道单链表在插入和删除上比较有优势。至内MessageQueue的内部实现，
到这里知道Handler发送的消息最终会添加到MessageQueue中，但到达MessageQueue后消息又是如何处理的呢？
4. 还记得我们前面说过MessageQueue是由Looper负责管理的吧，现在我们就来看看Looper到底是如何管理MessageQueue的？
public final class Looper {
// sThreadLocal.get() will return null unless you've called prepare().
//存放线程的容器类,为确保获取的线程和原来的一样
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper; // guarded by Looper.class
final MessageQueue mQueue;
final Thread mThread;
//perpare()方法，用来初始化一个Looper对象
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));
}
//handler调用的获取Looper对象的方法。实际是在ThreadLocal中获取。
public static Looper myLooper() {
return sThreadLocal.get();
}
//Looper类的构造方法，可以发现创建Looper的同时也创建了消息队列MessageQueue对象
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mRun = true;
mThread = Thread.currentThread();
}
//这个方法是给系统调用的，UI线程通过调用这个线程，从而保证UI线程里有一个Looper
//需要注意：如果一个线程是UI线程，那么myLooper和getMainLooper是同一个Looper
public static final void prepareMainLooper() {
prepare();
setMainLooper(myLooper());
if (Process.supportsProcesses()) {
myLooper().mQueue.mQuitAllowed = false;
}
}
//获得UI线程的Looper,通常我们想Hanlder的handleMessage在UI线程执行时通常会new Handler(getMainLooper());
public synchronized static final Looper getMainLooper() {
return mMainLooper;
}
//looper中最重要的方法loop()，该方法是个死循环，会不断去消息队列MessageQueue中获取消息，然后调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;
//死循环
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
//这里其实就是调用handler中的方法，而在Handler的源码中也可以知道dispatchMessage(msg)内部调用的就是handlerMessage()方法
msg.target.dispatchMessage(msg);
msg.recycle();
}
}
分析：代码不算多，我们拆分开慢慢说.
在Looper源码中得知其内部是通过一个ThreadLocal的容器来存放Looper的对象本身的，这样就可以确保每个线程获取到的looper都是唯一的。那么Looper对象是如何被创建的呢？通过源码知道perpare()方法就可以创建Looper对象：
//perpare()方法，用来初始化一个Looper对象
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对象前先会去判断ThreadLocal中是否已经存在Looper对象，如果不存在就新创建一个Looper对象并且存放ThreadLocal中。这里还有一个注意是在Looper创建的同时MessageQueue消息队列也被创建完成，这样的话Looper中就持有了MessageQueue对象。
//Looper类的构造方法，可以发现创建Looper的同时也创建了消息队列MessageQueue对象
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mRun = true;
mThread = Thread.currentThread();
}
那么我们如何获取已经创建好的Looper对象呢？通过源码知道myLooper()方法就可以获取到Looper对象：
//handler调用的获取Looper对象的方法。实际是在ThreadLocal中获取。
public static Looper myLooper() {
return sThreadLocal.get();
}
Looper对象的创建和获取，还有MessageQueue对象的创建，现在我们都很清楚了，但是Looper到底是怎么管理MessageQueue对象的呢？这就要看looper()方法了：
//looper中最重要的方法loop()，该方法是个死循环，会不断去消息队列MessageQueue中获取消息，然后调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;
//死循环
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
//这里其实就是调用handler中的方法，而在Handler的源码中也可以知道dispatchMessage(msg)内部调用的就是handlerMessage()方法
msg.target.dispatchMessage(msg);
msg.recycle();
}
通过looper()方法内部源码知道，首先会通过myLoooper()去获取一个Looper对象，
如果Looper对象为null，就会报出一个我们非常熟悉的错误提示，“No Looper;Looper.prepare() wasn't called on this thread”,要求我们先通过Looper.prepare()方法去创建Looper对象；
如果Looper不为null，那么就会去获取消息队列MessageQueue对象，接着就进入一个for的死循环，不断从消息队列MessageQueue对象中获取消息，如果消息不为空，那么久会调用msg.target的dispatchMessage(Message)方法，那么这个target又是什么，没错target就是我们创建的Handler对象，还记得我们前面分析Handler源码时说过的那个方法嘛？
// 在looper类中的loop()方法内部调用的方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
现在明白了吧？
首先，检测Message的callback是否为null，不为null就通过handleCallback方法来处理消息，那么Message的callback是什么？其实就是一个Runnable对象，实际上就是Handler的post方法所传递的Runnable参数,顺便看看post方法源码：
public final boolean post(Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
getPostMessage(Runnable r)方法源码：
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
现在明白Message的callback是什么了吧？而对应handleCallback方法逻辑也比较简单：
private static void handleCallback(Message message) {
message.callback.run();
}
嗯，是的，因此最终执行的还是通过post方法传递进来的Runnable参数的run方法。好了，继续dispatchMessage()分析，接着会去检查mCallback是否为null，不为null，则调用mCallback的handleMessage方法来处理消息。至于Callback则就是一个接口定义如下：
public interface Callback {
public boolean handleMessage(Message msg);
}
这个接口有什么用呢？其实通过Callback接口我们就可以采取如下方法来创建Handler对象：
Handler handler =new Handler(callback)
那么这样做到底有什么意义，其实这样做可以用callback来创建一个Handler的实例而无需派生Handler的子类。在我们的开发过程中，我们经常使用的方法就是派生一个Hanlder子类并重写其handleMessage方法来处理具体的消息，而Callback给我们提供了另外一种方式，那就是当我们不想派生子类的时候，可以通过Callback来实现。
继续dispatchMessage()方法的分析，最后如果以上条件都不成立的话，就会去调用Handler的handleMessage方法来处理消息。而 Handler是在主线程创建的，也就是说Looper也是主线程的Looper，因此handleMessage内部处理最终都会在主线程上执行，就这样整个流程都执行完了。
