Android 消息机制主要是指 Handler 的运行机制。
**Handler **
Handler 的运行需要底层的 MessageQueue 和 Looper 的支撑。**MessageQueue **
MessageQueue 的中文翻译是消息队列，它的内部存储了一组消息，以队列形式对外提供插入和删除的工作。它的内部采用单链表的数据结构来存储消息列表。Looper
Looper 的中文翻译是循环，这里可以理解为消息循环。由于 MessageQueue 只是一个消息存储单元，它不能去处理消息，Looper 会以无限循环的形式去查找是否有新消息，如果有就处理，否则就一直等待。ThreadLocal
Looper 中还有一个特殊的概念 ThreadLocal，ThreadLocal 并不是线程，它的作用是可以在每个线程中存储数据。当 Handler 创建时会采用当前 Looper 来构造消息循环系统，这时候就要使用 ThreadLocal，ThreadLocal可以在不同的线程中互不干扰地存储并提供数据，通过 ThreadLocal 可以获取每个线程的 Looper。主线程（UI）
线程是默认没有 Looper 的，如果需要使用 Handler 就必须为线程创建 Looper。主线程（UI），它就是 ActivityThread ，ActivityThread 被创建时就会初始化 Looper，这也是在主线程中默认可以使用 Handler 的原因。
10.1 Android 的消息机制概述
Handler 的主要作用是将一个任务切换到某个指定的线程中去执行。Android 规定访问 UI 只能在主线程中进行，否则程序会抛异常，就是常见的 ANR：
public final class ViewRootImpl implements ...{
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 访问的销量，因为锁机制是阻塞某些线程的执行；
最简单且高效的方法就是采用单线程模型来处理 UI 操作（Handler）。
Handler创建时会采用当前线程的Looper来构建内部的消息循环系统，如果当前线程没有Looper就会报错。
Handler可以通过post方法发送一个Runnable到消息队列中，也可以通过send方法发送一个消息到消息队列中，其实post方法最终也是通过send方法来完成。send 方法会调用 MessageQueue 的 enqueueMessage 方法将这个消息放入消息队列中，然后 looper 会处理这个消息，消息中的 Runnable 或者 Handler 的 handleMessage 方法就会被调用。
Looper 是运行在创建 Handler 所在的线程中，这样 Handler 中的业务逻辑就被切换到创建 Handler 所在的线程中去执行了。
10.2 Android 的消息机制分析
10.2.1 ThreadLocal 的工作原理
ThreadLocal 的使用场景：
当某些数据是以线程为作用域并且不同线程具有不同数据副本的时候。
对于 Handler 来说，它需要获取当前线程的 Looper，Looper 的作用域就是线程，并且不同现场具有不同的 Thread，通过 ThreadLocal 就能轻松实现 Looper 在线程中的存取。复杂逻辑下的对象传递
比如监听器的传递，当一个线程中的任务过于复杂，我们又需要监听器能够贯穿整个线程的执行过程，采用 ThreadLocal 可以让监听器作为线程内的全局对象而存在，在线程内部只要 get 方法就能获取监听器。
private ThreadLocal mBooleanThreadLocal = new ThreadLocal<>();
mBooleanThreadLocal.set(true);
Log.d(TAG, "mBooleanThreadLocal.get = "+mBooleanThreadLocal.get());
new Thread("Thread#1"){
@Override
public void run() {
Log.d(TAG, "Thread#1 mBooleanThreadLocal.get = "+mBooleanThreadLocal.get());
mBooleanThreadLocal.set(false);
Log.d(TAG, "Thread#1 mBooleanThreadLocal.get = "+mBooleanThreadLocal.get());
}
}.start();
new Thread("Thread#2"){
@Override
public void run() {
Log.d(TAG, "Thread#2 mBooleanThreadLocal.get = "+mBooleanThreadLocal.get());
}
}.start();
}
D/MainActivity: mBooleanThreadLocal.get = true
D/MainActivity: Thread#1 mBooleanThreadLocal.get = null
D/MainActivity: Thread#1 mBooleanThreadLocal.get = false
D/MainActivity: Thread#2 mBooleanThreadLocal.get = null
虽然在不同的线程中访问同一个 ThreadLocal 对象，但是获取到的值却是不一样的。因为在不同线程访问同一个 ThreadLocal 的 get 方法，ThreadLocal 的内部会从各自的线程中去一个数组。
ThreadLocal 可以再不同的线程中维护一套数据的副本并且彼此互不干扰。
分析 ThreadLocal ，先看 set：
public class ThreadLocal {
...
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
...
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
...
createMap 方法为一个线程创建一个 map，这样每个线程的 map 都是独立的
private ThreadLocalMap(ThreadLocalMap parentMap) {
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];
for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
if (e != null) {
ThreadLocal key = e.get();
if (key != null) {
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
上面的 set 方法中，会在一个 map 中保存 ThreadLoacl 的值，map 会在 Thread 中被初始化。
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals= null;
Thread(ThreadGroup group, String name, int priority, boolean daemon) {
...
init2(currentThread());
}
...
private void init2(Thread parent) {
this.contextClassLoader = parent.getContextClassLoader();
this.inheritedAccessControlContext = AccessController.getContext();
if (parent.inheritableThreadLocals != null) {
this.inheritableThreadLocals = ThreadLocal.createInheritedMap(
parent.inheritableThreadLocals);
}
}
get 方法：
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
}
...
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
从 ThreadLocal 的set 和 get 方法可以看出，它们所操作的对象都是当前线程的 map 对象，因此在不同线程中访问同一个 ThreadLocal 的set 和 get 方法，它们的读写操作仅限于各自线程的内部。
10.2.2 消息队列的工作原理
MessageQueue 主要两个操作：插入和读取。
读取
读取本身会伴随这删除操作，对应方法 next：从消息队列去除一条消息并将其移除插入
对应方法 enqueueMessage：通过一个单链表的数据结构来维护消息列表（单链表在插入和删除上比较有优势）
boolean enqueueMessage(Message msg, long when) {
...
}
源码中的 enqueueMessage 主要操作就是单链表的插入操作。
Message next() {
int pendingIdleHandlerCount = -1; // -1 only during first iteration
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 {
// No more messages.
nextPollTimeoutMillis = -1;
}
...
}
next 方法是一个无线循环的方法，消息队列如果没有消息，那么 next 方法会一直阻塞在这里，当有新消息到来时，next 方法就会返回这条消息并将其从单链表中移除。
10.2.3 Looper 的工作原理
Looper 在 Android 的消息机制中扮演这消息循环的角色，它会不停的从 MessageQueue 中查看是否有消息。
public final class Looper {
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
...
Handler 的工作需要 Looper，通过 Looper.prepare()即可为当前线程创建一个 Looper，接着通过 Looper.loop（）来开启消息循环。
new Thread("Thread#2"){
@Override
public void run() {
Looper.prepare();
Handler handler = new Handler();
Looper.loop();
}
}.start();
Looper 里面有几个方法：
- ** prepare：**开启为当前线程创建一个 Looper；
- ** loop：**开启消息循环；
- prepareMainLooper：给主线程也就是 ActivityThread 创建 Looper，本质也是 prepare；
- getMainLooper：可以在任何地方获取到主线的 Looper；
- quit：直接退出 Looper
- quitSafely：设定一个退出标记，然后把消息队列已有的消息处理完毕后才安全退出；
Looper 退出后，通过 Handler 放送的消息会失败，send 方法会返回 false。在子线程中，如果手动创建了 Looper ，那么在所有的事情完成后应该调用 quit 方法来终止消息循环，否则会一直处于等待的状态。
Looper 最重要的一个方法是 loop，必须要调用。
public static void loop() {
final Looper me = myLooper();
// ThreadLocal 判断是否为空
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
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 {
//传递消息给 handler 处理
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();
}
}
loop 方法是个死循环，唯一跳出循环的方式是 MessageQueue 的 next 返回了null。当 Looper 的 quit 方法被调用时，Looper 才会调用 MessageQueue 的 quit 或者 quitSafrly 方法来通知消息队列退出，当消息队列被标记为退出状态时，它的 next 方法才会返回 null。也就是说 Looper 必须退出，否则 next 方法一直阻塞，loop 也会一直阻塞。当 MessageQueue 的 next 返回了新消息，Looper 就会处理调用 msg.target.dispatchMessage(msg)，msg.target 是发送这条消息的 Handler 对象，这样 Handler 发送的消息最终又交给它的 dispatchMessage 方法来处理。这里不同的是， Handler 的 dispatchMessage 方法是在创建 Handler 时所使用的 Looper 中执行的，这样就成功的切换到了指定的线程中。
10.2.4 Handler 的工作原理
Handler 的工作主要包含消息的发送和接收过程。下面是 send 的一系列方法：
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
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 sendEmptyMessageAtTime(int what, long uptimeMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageAtTime(msg, uptimeMillis);
}
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;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
MessageQueue 的 next 方法返回这条消息给 Looper 。looper 收到消息调用 Handler 的 dispatchMessage 处理。
public void dispatchMessage(Message msg) {
// 检查 Message 的callback 是否为null
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
Message 的 callback 是一个 Runnable 对象，实际上就是 Handler 的 post 方法所传递的 Runnable 参数。
private static void handleCallback(Message message) {
message.callback.run();
}
其次检查 mCallback 是否是 null。不为null 就调用 mCallback 的 handleMessage 方法来处理消息。
public interface Callback {
public boolean handleMessage(Message msg);
}
Callback 的意义在于我们可以这样创建 Handler：Handler handler = new Handler(callback);，而不仅仅是创建：private class MyHandler extends Handler { }
Handler 还可以通过一个特点的 Looper 来构造 Handler。
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class 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;
}
上述代码说明了 Handler 必须有 Looper，否则就会抛出异常。
10.3 主线程的消息循环
Android 的主线程就是 ActivityThread，主线程的入口方法为 main：
public final class ActivityThread {
public static void main(String[] args) {
....
Process.setArgV0("");
//创建主线程 Looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
//创建一个 Handler
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
// 开始 loop 循环
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
public final class ActivityThread {
final H mH = new H();
final Handler getHandler() {
return mH;
}
private class H extends Handler {
....
ActivityThread 通过 ApplicationThread 和 AMS 进行进程间通信，AMS 以进程间通信的方式完成了 ActivityThread 的请求后会回调 ApplicationThread 中的 Binder 方法，然后 Application 会向 H 发送消息，H 收到消息后会将 ApplicationThread 中的逻辑切换到 ActivityThread 中去执行，即切换到主线程，这个过程就是主线程的消息循环模型。