Handler并不是专门用于更新UI，它只是常被开发者用来更新UI。
Android的消息机制主要指Handler的运行机制，底层需要MessageQueue和Looper的支撑。MessageQueue是采用单链表的数据结构来存储消息列表的，Looper为消息循环。由于MessageQueue是一个消息的存储单元，不能处理信息，Looper就填补了这一功能，Looper会以无限循环的方式去查找是否有新消息，有就处理，没有就等待。Looper还有一个ThreadLocal，可以在每个线程中存储数据。通过ThreadLocal可以获取每个线程的Looper，一般线程默认是没有Looper，除了UI线程，所以就必须创建Looper。
一、Android消息机制概述
Handler的主要功能是将一个任务切换到某个指定的线程中去操作，这是因为Android规定UI操作只能在主线程，不然就会抛出异常，原因是因为ViewRootImpl对UI操作做了验证，通过ViewRootImpl的checkThread方法来完成。
系统提供Handler的主要原因是为了解决子线程中无法访问到UI的矛盾。
这是因为Android的UI控件不是线程安全的，如果多线程访问会导致UI处于不可预期状态，如果加上锁机制，会有两个问题：
- 加上锁会导致让UI访问的逻辑变得复杂
- 降低UI的访问效率
一般创建Handler的时候需要有Looper，不然会出现异常。
Handler创建以后，会同内部的Looper以及MessageQueue一起协同工作，然后Handler的post方法将一个Runanble投递到Handler内部的Looper中去处理，其实post也是通过send方法来完成的，当调用send方法时，会调用MessageQueue的enqueueMessage方法将消息放到消息队列中，然后Looper发现有新的消息来时，则会处理这个消息，最后消息中的Runnable或者Handler的handleMessage方法会被调用。注意Looper是运行在创建Handler所在的线程中的，这样一来Handler中的业务逻辑就被切换到创建Handler所在的线程中去执行。
二、Android的消息机制分析
1.ThreadLocal的工作原理
ThreadLocalThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其它线程来说无法获取到数据。ThreadLocal另一个使用场景是复杂逻辑下的对象传递，比如监听器的传递，有些时候一个线程中的任务过于复杂，这可能表现为函数调用栈比较深以及代码入口的多样性，在这种情况下，我们又需要监听器能够贯穿整个线程的执行过程，这个时候可以怎么做呢？其实就可以采用ThreadLocal，采用ThreadLocal可以让监听器作为线程内的全局对象而存在，在线程内部只要通过get方法就可以获取到监听器。
介绍了那么多ThreadLocal的知识，可能还是有点抽象，下面通过实际的例子为大家演示ThreadLocal的真正含义。首先定义一个ThreadLocal对象，这里选择Boolean类型的，如下所示：
private ThreadLocalmBooleanThreadLocal = new ThreadLocal();
然后分别在主线程、子线程1和子线程2中设置和访问它的值，代码如下所示：
mBooleanThreadLocal.set(true);
Log.d(TAG, "[Thread#main]mBooleanThreadLocal=" + mBooleanThreadLocal.get());
new Thread("Thread#1") {
@Override
public void run() {
mBooleanThreadLocal.set(false);
Log.d(TAG, "[Thread#1]mBooleanThreadLocal=" + mBooleanThreadLocal.get());
};
}.start();
new Thread("Thread#2") {
@Override
public void run() {
Log.d(TAG, "[Thread#2]mBooleanThreadLocal=" + mBooleanThreadLocal.get());
};
}.start();
在上面的代码中，在主线程中设置mBooleanThreadLocal的值为true，在子线程1中设置mBooleanThreadLocal的值为false，在子线程2中不设置mBooleanThreadLocal的值，然后分别在3个线程中通过get方法去mBooleanThreadLocal的值，根据前面对ThreadLocal的描述，这个时候，主线程中应该是true，子线程1中应该是false，而子线程2中由于没有设置值，所以应该是null，安装并运行程序，日志如下所示：
D/TestActivity(8676):[Thread#main]mBooleanThreadLocal=true
D/TestActivity(8676):[Thread#1]mBooleanThreadLocal=false
D/TestActivity(8676):[Thread#2]mBooleanThreadLocal=null
从上面日志可以看出，虽然在不同线程中访问的是同一个ThreadLocal对象，但是它们通过ThreadLocal来获取到的值却是不一样的，这就是ThreadLocal的奇妙之处。结合这这个例子然后再看一遍前面对ThreadLocal的两个使用场景的理论分析，大家应该就能比较好地理解ThreadLocal的使用方法了。ThreadLocal之所以有这么奇妙的效果，是因为不同线程访问同一个ThreadLocal的get方法，ThreadLocal内部会从各自的线程中取出一个数组，然后再从数组中根据当前ThreadLocal的索引去查找出对应的value值，很显然，不同线程中的数组是不同的，这就是为什么通过ThreadLocal可以在不同的线程中维护一套数据的副本并且彼此互不干扰。
ThreadLocal是一个泛型类，它的定义为public class ThreadLocal
首先看ThreadLocal的set方法，如下所示：
public void set(T value) {
Thread currentThread = Thread.currentThread();
Values values = values(currentThread);
if (values == null) {
values = initializeValues(currentThread);
}
values.put(this, value);
}
在上面的set方法中，首先会通过values方法来获取当前线程中的ThreadLocal数据，如果获取呢？其实获取的方式也是很简单的，在Thread类的内容有一个成员专门用于存储线程的ThreadLocal的数据，如下所示：ThreadLocal.Values localValues，因此获取当前线程的ThreadLocal数据就变得异常简单了。如果localValues的值为null，那么就需要对其进行初始化，初始化后再将ThreadLocal的值进行存储。下面看下ThreadLocal的值到底是怎么localValues中进行存储的。在localValues内部有一个数组：private Object[] table，ThreadLocal的值就是存在在这个table数组中，下面看下localValues是如何使用put方法将ThreadLocal的值存储到table数组中的，如下所示：
void put(ThreadLocal key, Object value) {
cleanUp();
// Keep track of first tombstone. That's where we want to go back
// and add an entry if necessary.
int firstTombstone = -1;
for (int index = key.hash & mask;; index = next(index)) {
Object k = table[index];
if (k == key.reference) {
// Replace existing entry.
table[index + 1] = value;
return;
}
if (k == null) {
if (firstTombstone == -1) {
// Fill in null slot.
table[index] = key.reference;
table[index + 1] = value;
size++;
return;
}
// Go back and replace first tombstone.
table[firstTombstone] = key.reference;
table[firstTombstone + 1] = value;
tombstones--;
size++;
return;
}
// Remember first tombstone.
if (firstTombstone == -1 && k == TOMBSTONE) {
firstTombstone = index;
}
}
}
面的代码实现数据的存储过程，这里不去分析它的具体算法，但是我们可以得出一个存储规则，那就是ThreadLocal的值在table数组中的存储位置总是为ThreadLocal的reference字段所标识的对象的下一个位置，比如ThreadLocal的reference对象在table数组的索引为index，那么ThreadLocal的值在table数组中的索引就是index+1。最终ThreadLocal的值将会被存储在table数组中：table[index + 1] = value。
上面分析了ThreadLocal的set方法，这里分析下它的get方法，如下所示：
public T get() {
// Optimized for the fast path.
Thread currentThread = Thread.currentThread();
Values values = values(currentThread);
if (values != null) {
Object[] table = values.table;
int index = hash & values.mask;
if (this.reference == table[index]) {
return (T) table[index + 1];
}
} else {
values = initializeValues(currentThread);
}
return (T) values.getAfterMiss(this);
}
可以发现，ThreadLocal的get方法的逻辑也比较清晰，它同样是取出当前线程的localValues对象，如果这个对象为null那么就返回初始值，初始值由ThreadLocal的initialValue方法来描述，默认情况下为null，当然也可以重写这个方法，它的默认实现如下所示：
/**
* Provides the initial value of this variable for the current thread.
* The default implementation returns {@code null}.
*
* @return the initial value of the variable.
*/
protected T initialValue() {
return null;
}
从ThreadLocal的set和get方法可以看出，它们所操作的对象都是当前线程的localValues对象的table数组，因此在不同线程中访问同一个ThreadLocal的set和get方法，它们对ThreadLocal所做的读写操作仅限于各自线程的内部，这就是为什么ThreadLocal可以在多个线程中互不干扰地存储和修改数据，理解ThreadLocal的实现方式有助于理解Looper的工作原理。
2.消息队列的工作原理
MessageQueue主要包含两个操作：插入和读取，插入和读取分为enqueueMessage和next，其中enqueueMessage是往消息队列中插入一条消息，next是从消息队列中去出一条消息并从消息队列中移除，MessageQueue实际上是使用单链表来实现的。
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);
}
}
return true;
}
它主要是实现单链表的插入操作。
Message next() {
....
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
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;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
}
}
}
next是一个无限循环的方法，如果没有消息，则一直阻塞，如果有消息则继续运行。
3.Looper的工作原理
Looper在Android的消息机制中就是用来进行消息循环的。它会不停地循环，去MessageQueue中查看是否有新消息，如果有消息就立刻处理该消息，否则就一直等待。
首线来看下Looper的构造方法：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
通过Looper.prepare()即可为当前线程创建一个Looper，接着通过Looper.loop()来开启消息循环：
new Thread("Thread 2"){
public void run(){
Looper.prepare();
Handler handler = new Handler();
Looper.loop();
}
}
Looper中除了prepare方法外，还提供了prepareMainLooper方法，这个方法主要是给主线程创建Looper使用的，即是属于ActivityThread的Looper，其本质也是通过prepare来实现的，同时Looper也提供一个getMainLooper方法，通过它可以在任何地方获取ActivityThread的Looper。Looper也是可以退出的，它提供了quit和quitSafely方法来退出，二者的区别是：quit直接退出Looper，quitSafely只是设置一个退出标志，等消息队列中的消息处理完毕，就会退出Looper，这时候Handler的send方法返回false。如果在子线程中手动创建了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.");
}
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
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.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
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();
}
}
Looper的loop方法也很好理解，loop是一个死循环的方法，唯一跳出死循环的方式是MessageQueue的next方法返回null。当Looper的quit方法被执行的时候，Looper会调用MessageQueue的quit或者quitSafely方法来通知消息队列退出，当被标记退出，消息队列就会返回null。loop的阻塞是因为MessageQueue的next方法阻塞造成的。如果MessageQueue的next方法返回新消息了，那就会调用msg.target.dispatchMessage(msg)来处理，其中msg.target是Handler对象，dispatchMessage虽然是通过Handler调用的，但是是在创建Handler时所使用的Looper中执行的，也就是在当前Looper中或者线程中执行的，这样就可以实现线程的切换。
4. Hanler的工作原理
Handler的工作主要包含消息的发送和接受过程。消息的发送可以通过post或者send的一系列方法来实现，如下所示：
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
/**
* Sends a Message containing only the what value.
*
* @return Returns true if the message was successfully placed in to the
* message queue. Returns false on failure, usually because the
* looper processing the message queue is exiting.
*/
public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}
/**
* Sends a Message containing only the what value, to be delivered
* after the specified amount of time elapses.
* @see #sendMessageDelayed(android.os.Message, long)
*
* @return Returns true if the message was successfully placed in to the
* message queue. Returns false on failure, usually because the
* looper processing the message queue is exiting.
*/
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
/**
* Sends a Message containing only the what value, to be delivered
* at a specific time.
* @see #sendMessageAtTime(android.os.Message, long)
*
* @return Returns true if the message was successfully placed in to the
* message queue. Returns false on failure, usually because the
* looper processing the message queue is exiting.
*/
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageAtTime(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队列插入一条消息，然后MessageQueue就会调用next方法返回这条消息给Looper，Looper会开始交由Handler处理，即Handler的dispatchMessage方法会被调用，dispatchMessage的实现如下：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
Handler的消息处理过程如下：
- 首先先检查Message的callback是否为空，不为空就通过handleCallback来处理，Message的callback是一个Runnable对象，实际上就是Handler的post方法所传递的Runnable参数，handlerCallback的逻辑如下：
private static void handleCallback(Message message) {
message.callback.run();
}
- 其次检查mCallback是否为null，不为null就调用mCallback的handleMessage方法来处理，Callback是个接口，定义如下：
public interface Callback {
public boolean handleMessage(Message msg);
}
通过Callback可以采用如下方法创建Handler handler = new Handler(callable)。在日常开发中，创建Handler最常见的方式是派生一个Handler的子类并且重写它的handleMessage方法，另外一种是传入一个Callback，并实现callback的handleMessage方法。
最后调用Handler的handleMessage方法来处理消息。
处理过程的流程图：
Handler还有一个特殊的构造方法，通过一个特定的Looper来构造Handler，实现一些特殊的功能。
三、主线程的消息循环
Android的主线程是ActivityThread，主线程的方法入口是mian方法，main方法通过Looper.prepareMainLooper()来创建主线程的Looper和MessageQueue，并通过Looper.loop()来启动循环。主线程的消息循环开始后，需要一个Handler来进行处理和发送，这个就是ActivityThread.H,内部有一组消息类型。ActivityThread通过ApplicationThread和AMS进行通信，AMS一进程间通信完成ActivityThread的请求后回调ApplicationThread的Binder方法，然后像H发送消息，H收到后会将ApplicationThread中的逻辑切换到ActivityThread中去执行，即切换到主线程中。
CSDN博客：http://blog.csdn.net/aaaaa_sean_m/article/details/74079912