为什么要使用Handler
-
因为在Android中访问UI只能在主线程中进行，如果在子线程中运行，则程序会抛出异常。
// ViewRootImpl.java void checkThread() { if (mThread != Thread.currentThread()) { throw new CalledFromWrongThreadException( "Only the original thread that created a view hierarchy can touch its views."); } } -
为什么不允许在子线程中访问UI？
因为Android的UI并不是线程安全的，如果在多线程中执行UI的操作，那么UI的状态是不可控的，这个时候就会出现各种问题。
那么最好的办法就是只能在一个线程中执行UI的操作。
而Android主线程中又不能执行耗时操作，因为那样就会导致程序的ANR。
所以Android提供了Handler这样的机制，用来在子线程中执行耗时操作之后，发送消息给主线程，主线程再执行UI的更新操作。
Handler机制原理分析
这里我们以Android UI线程的Handler来分析。
Handler的创建
Android的应用入口是ActivityThread.main()函数，UI线程的Handler就是在这个函数中创建的。
public static void main(String[] args) {
Looper.prepareMainLooper();
thread.attach(false);
ActivityThread thread = new ActivityThread();
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
Looper.loop();
}
当main函数执行之后，应用就启动了，从这个时候开始，Looper就会一直从消息队列中取出消息并处理。而应用会通过Handler来不断的添加消息给消息队列。通过不断的添加消息和取出消息，整个消息机制就被运转起来了。
Looper
从上面可以看到在Handler创建前后，通过Looper的prepare和loop方法，创建了Looper对象和开启消息循环。
-
构造函数
private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }- 创建了MessageQueue对象，这个对象是消息队列，主要用来存放我们的消息，会在下面具体分析。
- 获取当前的线程并保存起来
-
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)); }- 判断ThreadLocal中在当前线程是否已经存在了Looper对象，如果存在，则抛出异常，所以可以得出在同一个线程中只能存在一个Looper对象。
- 在ThreadLocal存入当前线程的Looper对象。
- ThreadLocal对象是一个线程内部的数据存储类，通过它可以在指定的线程存储数据，当存储数据之后，就只能在指定的线程中获取到存储的数据，其他线程是不能获取到数据的。
-
loop
public static void loop() { final Looper me = myLooper(); // 获取消息队列 final MessageQueue queue = me.mQueue; // 死循环来轮询的从消息队列中获取消息 for (;;) { Message msg = queue.next(); // might block if (msg == null) { return; } try { msg.target.dispatchMessage(msg); } finally { if (traceTag != 0) { Trace.traceEnd(traceTag); } } msg.recycleUnchecked(); } }- loop函数会不断的从消息队列中取出消息，当queue.next()为空的时候就直接阻塞住
- msg不为空，调用
msg.target.dispatchMessage(msg)处理消息，而msg.target其实就是Handler对象，取出消息之后就交给Handler来处理发送的消息了。
-
quit
public void quit() { mQueue.quit(false); } public void quitSafely() { mQueue.quit(true); }调用MessageQueue的quit方法来退出Looper。其中上面的是直接退出，下面的是安全的退出，也就是只标记一下，当消息队列中的消息全部执行完成之后安全的退出。
当我们在子线程中创建Looper和Handler的时候，如果我们不调用quit方法的话，子线程就会一直处于等待状态，所以我们需要调用quit方法退出Looper。
MessageQueue
在Looper中大量的使用到了MessageQueue，而MessageQueue主要就是两个操作插入消息和读取消息并删除消息，我们来一起分析下：
-
构造函数
MessageQueue(boolean quitAllowed) { mQuitAllowed = quitAllowed; mPtr = nativeInit(); }在构造函数中，调用了
nativeInit方法在Native层创建了NativeMessageQueue和Looper，并将Looper设置给当前的线程。这个时候Java层和Native层都有了MessageQueue和Looper。
在Native层的Looper中，创建了一个管道，本质上就是一个文件，一个管道中有读和写两个文件操作符，通过读和写来将消息写入和读取。 -
enqueueMessage 插入消息
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) { // New head, wake up the event queue if blocked. 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; // invariant: p == prev.next prev.next = msg; } // We can assume mPtr != 0 because mQuitting is false. if (needWake) { nativeWake(mPtr); } } return true; }enqueueMessage其实就是构建好msg，并插入到单链表中。
-
next 读取消息并删除消息
Message next() { for (;;) { nativePollOnce(ptr, nextPollTimeoutMillis); } }next方法是一个无限循环方法，当消息队列中没有消息的时候，next方法会被阻塞在这里，当有新的消息的时候，next方法会最终返回这条消息并从单链表中移除。
Handler
-
构造函数
public Handler(Callback callback, boolean async) { 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对象为空，则抛出异常，所以当我们在子线程中创建Handler的时候，首先要通过
Looper.prepare()来创建子线程的Looper对象。 - 通过Looper获取到MessageQueue
- 首先获取Looper对象，如果Looper对象为空，则抛出异常，所以当我们在子线程中创建Handler的时候，首先要通过
-
发送消息
Handler的发送消息主要是post的方法和send的方法，而他们最终调用的都是：
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; if (mAsynchronous) { msg.setAsynchronous(true); } return queue.enqueueMessage(msg, uptimeMillis); }Handler主要就是向消息队列中插入了一条消息，这个时候MessageQueue就会调用插入的方法来插入消息。
-
读取消息
当Handler发送消息之后，MessageQueue就会通过next方法读取出这个消息，那么Looper的loop就不会被阻塞住，取出消息之后就调用了
msg.target.dispatchMessage(msg)方法，最终交给Handler的dispatchMessage来执行。/** * 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); } }-
检查Message的callback是否为空，不为空则通过
handleCallback来处理，而callback就是通过post传递过来的Runnable对象。直接调用run方法执行。private static void handleCallback(Message message) { message.callback.run(); } -
检查mCallback是否为空，不为空则调用
mCallback.handleMessage方法处理消息。而mCallback就是我们在创建Handler的时候传递过去的callback。public interface Callback { public boolean handleMessage(Message msg); } public Handler(Callback callback) { this(callback, false); } 调用
handleMessage(msg)处理消息。
-
