前言
Handler是Android的消息机制，他能够很轻松的在线程间传递数据。由于Android开发规范的限制，我们不能在主线程执行耗时操作（如网络，IO操作等），不能在子线程更新UI，所以Handler大部分用来在耗时操作与更新UI之间切换。这让很多人误以为Handler就是用来更新UI的，其实这只是它的一小部分应用。
开始
我相信大多数人对Handler的用法已经烂熟于心了，这篇文章不会去探讨Handler的使用，而是着重从源码上分析Handler的运行机制。
想要了解Handler的运行机制，我们需要了解 MessageQueue ，Message，Looper 这几个类。
-
MessageQueue的意思就是消息队列，它存储了我们需要用来处理的消息Message。 -
Message是消息类，内部存在一个Bundle对象和几个public字段存储数据，MessageQueue作为一个消息队列不能自己处理消息，所以需要用到Looper。 -
Looper是一个循环装置，他负责从不断从MessageQueue里取出Message，然后回调给Handler的handleMessage来执行具体操作。 -
Handler在这里面充当的角色更像是一个辅助类，它让我们不用关系MessageQueue和Looper的具体细节，只需要关系如何发送消息和回调的处理就行了。
上面讲了几个关键类在Handler运行机制中的职责，相对大家对Handler机制有个粗略的了解。
我相信各位看官在阅读这篇文章前都是带着问题的，我们将通过问题来解答大家的疑惑。
分析
Looper
在分析Looper之前，我们还需要知道ThreadLocal这个类，如果对ThreadLocal还不太了解，可以去看我的另一篇文章《ThreadLocal详解》。
Looper是如何创建？
Handler执行的线程和它持有的Looper有关。每个Thread都可以创建唯一的Looper对象。
//为当前线程创建Looper对象的方法。
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
//使用ThreadLocal来存储当前线程的Looper对象，这保证了每个线程有且仅有一个Looper对象。
//这里做了非空判断，所以在同一个线程prepare方法是不允许被调用两次的
//第一次创建好的Looper对象不会被覆盖，它是唯一的。
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
那么主线程的Looper对象是怎么创建的呢？
public static void prepareMainLooper() {
//其实主线程创建Looper和其他线程没有区别，也是调用prepare()。
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
//但是Looper用sMainLooper这个静态变量将主线程的Looper对象存储了起来
//可以通过getMainLooper()获取，存储MainLooper其实非常有作用，下面会讲到。
sMainLooper = myLooper();
}
}
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}
Looper是如何从MessageQueue取出消息并分发的？
Looper分发消息的主要逻辑在loop方法里
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static void loop() {
final Looper me = myLooper();
//保证当前线程必须有Looper对象，如果没有则抛出异常，调用Looper.loop()之前应该先调用Looper.prepare().
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//Looper需要不断从MessageQueue中取出消息，所以它持有MessageQueue对象
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 (;;) {
//这里开始执行死循环，queue通过调用next方法来取出下一个消息。
//很多人很疑惑死循环不会相当耗费性能吗，如果没有那么多消息怎么办？
//其实当没有消息的时候，next方法会阻塞在这里，不会往下执行了，性能问题不存在。
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
//这里满足了死循环跳出的条件，即取出的消息为null
//没有消息next不是会阻塞吗，怎么会返回null呢？
//其实只有MessageQueue停止的时候（调用quit方法），才会返回null
//MessageQueue停止后，调用next返回null，且不再接受新消息，下面还有详细介绍。
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是Handler对象，分发消息到Handler去执行。
//有人问主线程可以创建这么多Handler，怎么保证这个Handler发送的消息不会跑到其它Handler去执行呢？
//那是因为在发送Message时，他会绑定发送的Handler，在此处分发消息时，也只会回调发送该条消息的Handler。
//那么分发消息具体在哪个线程执行呢？
//我觉得这个不该问，那当然是当前方法在哪个线程调用就在哪个线程执行啦。
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);
}
//这里对Message对象进行回收，会清空所有之前Message设置的数据。
//正是因为Message有回收机制，我们在创建消息的时候应该优先选择Message.obtain().
//如果发送的消息足够多，Message缓存的Message对象不够了，obtain内部会调用new Message()创建一个新的对象。
msg.recycleUnchecked();
}
}
Looper 分发的消息在哪个线程执行？
先给大家展示一段Looper文档上的示例代码
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare(); //创建LooperThread的Looper对象
mHandler = new Handler() {
public void handleMessage(Message msg) {
//处理发送过来的消息
}
};
Looper.loop(); //开始循环消息队列
}
}
上面这段代码相信很多人都写过，这是一段在子线程创建Handler的案例，其中handleMessage所执行的线程为LooperThread，因为Looper.loop()执行在LooperThread的run方法里。可以在其他线程通过mHandler发送消息到LooperThread
如果不调用Looper.prepare()直接new Handler()会怎么样呢？
我们可以查看Handler的源码看看无参构造是如何运行的
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());
}
}
//获取当前线程的Looper，如果不创建Looper会抛出异常。
//主线程我也没看到有调用Looper.prepare()啊，怎么在主线程不会抛异常呢？这个看下一个问题。
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;
}
主线程的Looper对象在哪里创建的？
从上一个问题可以看出如果不调用Looper.prepare()直接new Handler()就会抛出异常`
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");`
那么主线程的Looper在哪里创建的呢？首先它是创建了的，因为Looper.getMainLooper() != null，其实MainLooper创建的时间比我们想象的早，它在ActivityThread类里面，ActivityThread是Android的启动类，main方法就在里面（如果有人问你Android有没有main方法，你应该知道怎么回答了吧），而MainLooper就是在main方法里面创建的。
上代码：
//android.app.ActivityThread
public final class ActivityThread {
...
public static void main(String[] args) {
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());
Security.addProvider(new AndroidKeyStoreProvider());
// 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
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
AsyncTask.init();
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
//开启消息循环
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
}
MainLooper可以用来做什么
判断当前线程是否为主线程
因为Looper是在某一线程唯一的，那么可以在么做。如果
public static boolean isMainThread() {
//如果当前线程的Looper和MainLooper是同一个对象，那么可以认为当前线程是主线程
return Looper.myLooper() == Looper.getMainLooper() ;
}
但是也有人说下面这样也可以
public static boolean isMainThread() {
//这个方法其实是不准确的，线程的名称是可以随便更改的。
return Thread.currentThread().getName().equals("main");
}
所以用Looper来判断主线程是很好的做法
创建运行在主线程的Handler
Handler除了有无参构造，还有一个可以传入Looper的构造。通过指定Looper，可以在任意地方创建运行在主线程的Handler
class WorkThread extends Thread{
private Handler mHandler;
@Override
public void run() {
super.run();
mHandler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
//运行在主线程
}
};
mHandler.sendEmptyMessage(0);
}
}
Looper的quit方法和quitSafely方法有什么区别
下面是Looper两个方法的源码
public void quit() {
mQueue.quit(false);
}
public void quitSafely() {
mQueue.quit(true);
}
可以看出实际上是调用的MessageQueue的quit方法
下面是MessageQueue的源码
//android.os.MessageQueue
void quit(boolean safe) {
if (!mQuitAllowed) {
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
if (mQuitting) {
return;
}
mQuitting = true;
//如果调用的是quitSafely运行removeAllFutureMessagesLocked，否则removeAllMessagesLocked。
if (safe) {
//该方法只会清空MessageQueue消息池中所有的延迟消息，
//并将消息池中所有的非延迟消息派发出去让Handler去处理，
//quitSafely相比于quit方法安全之处在于清空消息之前会派发所有的非延迟消息。
removeAllFutureMessagesLocked();
} else {
//该方法的作用是把MessageQueue消息池中所有的消息全部清空，
//无论是延迟消息（延迟消息是指通过sendMessageDelayed或通过postDelayed等方法发送的需要延迟执行的消息）还是非延迟消息。
removeAllMessagesLocked();
}
// We can assume mPtr != 0 because mQuitting was previously false.
nativeWake(mPtr);
}
}
无论是调用了quit方法还是quitSafely方法，MessageQueue将不再接收新的Message，此时消息循环就结束，MessageQueued的next方法将返回null，结束loop()的死循环.这时候再通过Handler调用sendMessage或post等方法发送消息时均返回false，表示消息没有成功放入消息队列MessageQueue中，因为消息队列已经退出了。
Message
Message.obtain()和new Message()如何选择
Message提供了obtain等多个重载的方法来创建Message对象，那么这种方式和直接new该如何选择。下面看看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(); //只有当从对象池里取不出Message才去new
}
void recycleUnchecked() {
//清除所有使用过的痕迹
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++;
}
}
}
从上面代码可以看出，通过obtain方法是从对象池取，而new是创建了一个新的对象。我们应该使用obtain来创建Message对象，每次使用完后都会自动进行回收，节省内存。
......
