前言
Android 的消息机制原理是Android进阶必学知识点之一，在Android面试也是常问问题之一。在Android中，子线程是不能直接操作View,需要切换到主线程进行。那么这个切换动作就涉及到了Android的消息机制，也就是本文要讲的Handler、Looper、MessageQueue、Message它们之间的关系。
Handler
Handler在消息机制中扮演发送消息和处理消息的角色，也是我们平常接触最多的类。
Handler如何处理消息？
下面代码展示Handler如何处理消息。新建Handler对象，并重写handleMessage，在方法内处理相关逻辑,一般处理和主线程相关的逻辑。Handler有很多的构造器，下面构造器常用在主线程。
private Handler handler=new Handler(){
@Override
public void handleMessage(Message msg) {
if (msg.what==1){
Toast.makeText(MainActivity.this,"handle message",Toast.LENGTH_LONG).show();
}
}
};
复制代码Handler是如何发送消息的呢？
通过下面的代码可以了解到，Handler对象支持发送Message和Runable。Runable最终被包装成Message的callback实例变量（Handler对象处理消息会优先处理callback的逻辑），和Message一样的方式放到消息队列中。而每个方法都有相关的变形，支持延迟发送，或者未来的某段时间里发送等等。
//在消息池获取消息体，能达到消息重用，如果消息池没有消息，则新建消息
Message msg = handler.obtainMessage();
msg.what = 1;
//发送消息
handler.sendMessage(msg);
//发送空消息，参数会自动被包装msg.what=1
handler.sendEmptyMessage(1);
//未来的时间里发送消息
handler.sendEmptyMessageAtTime(1, 1000);
//延迟发送消息
handler.sendEmptyMessageDelayed(1, 1000);
msg = handler.obtainMessage();
msg.what = 2;
//将消息发送消息队列前面
handler.sendMessageAtFrontOfQueue(msg);
//发送任务，run方法内容将handler被处理。
handler.post(new Runnable() {
@Override
public void run() {
Log.i("Handler", "Runnable");
}
});
复制代码如果平常使用，我们只需要主线程定义Hanlder处理消息的内容，在子线程发送消息即可达到切换流程。
Looper
Looper负责循环的从消息队列中取消息，发送给Handler处理。因为消息队列只用来存储消息，所以需要Looper不断的从消息队列中取消息给Handler。默认情况，所有线程并不拥有Looper。如果在子线程直接执行Looper.loop方法，就会发生异常。那主线程为什么不会报错？在App的启动流程中，创建ActivityThread时，会调用Looper.prepare来创建Looper和MessageQueue，和Looper.loop开启循环。也就是系统为我们在主线程创建Looper和MessageQueue。所以，在子线创建Handler前，需要先调用Looper.prepare方法，创建Looper和MessageQueue。IntentService就是这样实现的。点击看IntentService的知识点。
MessageQueue
MessageQueue内部是以链表的形式组织的，主要作用是存储Message。在创建Looper的时候，会自动创建MessageQueue。
三者关系形成了Android的消息机制
Handler发送消息时会将消息插入到MessageQueue，而Looper不断的从MessageQueue中取消息分发给Handler处理。
源码解析
Handler的构建
我们先看一下Handler的构造器代码。
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 " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
//分析二
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
复制代码Handler有很多重载的构造器，我们常用在使用默认构造器，最终会调用上面的构造器。
分析一
通过Looper.myLooper()，获Looper的实例。而在myLooper的实现中，是通过ThreadLocal的get方法来获取的。如果ThreadLocal不存在Looper,则放回null。ThreaLocal这里可以简单理解为保存当前线程私有独立的实例，其他线程不可访问。如果ThreadLocal不存在Looper实例则，返回null。这也就是前面说的，在子线程创建Handler前，需要先调用Looper.prepare方法。否则会抛出RuntimeException。
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
复制代码分析二
mQueue为Looper中的消息队列，mCallBack定义了一个接口，用于回调消息处理。
public interface Callback {
/**
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
public boolean handleMessage(Message msg);
}
复制代码Handler发送消息
Handler所有发送消息方法的变体最终都会以下面方法放去到消息队列中。
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);
}
复制代码这里最重要的就是enqueueMessage方法中，将当前Handler对象设置给Message的target变量。然后调用队列queue的enqueueMessage方法。
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
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;
//如果队列为空或者插入message未来处理时间小于当前对头when
//则将当前消息设为队列头
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;
}
复制代码而在MessageQueue的enqueueMessage方法中，会先检查target是否null，message是否应在使用，当前线程是否退出，死亡状态。如果是，则抛出异常。如果当前队列是空或者阻塞，直接当前Message对象设为队列的头并唤醒线程。如果不是，则根据Message对象的when插入到队列合适的位置。因此可以看得出，Handler发送消息时是将消息放到队列中。
Looper和MessageQueue的创建
前面讲过，子线程使用Handler，需要调用Looper的静态prepare方法。
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,代用Looper就会报错。如果没有，new Looper并保存到ThreadLocal中。new Looper非常简单，只是新建一个MessageQueue,和持有当前线程。
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
复制代码Looper是如何实现循环的
在调用了Looper.prepare创建Looper和MessageQueue对象后，要调用Loop.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();
// Allow overriding a threshold with a system prop. e.g.
// adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
final int thresholdOverride =
SystemProperties.getInt("log.looper."
+ Process.myUid() + "."
+ Thread.currentThread().getName()
+ ".slow", 0);
boolean slowDeliveryDetected = false;
//分析一
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;
long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
if (thresholdOverride > 0) {
slowDispatchThresholdMs = thresholdOverride;
slowDeliveryThresholdMs = thresholdOverride;
}
final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);
final boolean needStartTime = logSlowDelivery || logSlowDispatch;
final boolean needEndTime = logSlowDispatch;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
final long dispatchEnd;
try {
//分析二：
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logSlowDelivery) {
if (slowDeliveryDetected) {
if ((dispatchStart - msg.when) <= 10) {
Slog.w(TAG, "Drained");
slowDeliveryDetected = false;
}
} else {
if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
msg)) {
// Once we write a slow delivery log, suppress until the queue drains.
slowDeliveryDetected = true;
}
}
}
if (logSlowDispatch) {
showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", 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.recycleUnchecked();
}
}
复制代码分析一： 通过无限制的for循环，读取队列的消息。而MessageQueue的next方法内部通过链表的形式，根据when属性的顺序返回message。
分析二: 调用Message对象的target的dipatchMessage方法。这里的target就是发送消息的Handler对象。而在Handler对象的dipatchMessage方法中，优先执行Message对象的callback方法，即优先执行我们发送消息时以Runable发送的任务，如果有的话。不然检测Callback对象的handleMessage方法，最后才是我们重写Hanlder对象的handleMessage方法。因为Handler不仅有默认构造函数，还有可以传入Callback,Looper等的构造函数。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
复制代码Message的复用
通过handler.obtainMessage而不是new方式获得消息实例。因为obtainMessage方法会先检测消息池是否有可以复用的消息，没有再去new一个消息实例。下面是类Message的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();
}
复制代码sPool的类型是Message，内部通过成员变量next,维护一个消息池。虽然叫消息池，内部却通过next不断的指向下一个Message,以链表维护的这个消息池，默认大小为50。在链表sPool不为空的情况，取表头Message元素,并将相关属性进行初始化。
那么Message对象是在什么时候被放进消息池中的呢？
在Looper的loop方法中，最后调用Message的recycleUnchecked方法
void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
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++;
}
}
}
复制代码在同步代码块，可以看到，将sPool指向当前要被回收的Message对象，而Message的next指向之前的表头。
总结
- 在子线程使用
Handler,需要先调用Looper.prepare方法，再调用Looper.loop方法。 - 消息队列以链表的形式维护着，消息的存放和获取顺序根据
when时间依次排列。 - 通过Handler，在子线程耗时操作，主线程更新UI。应用场景：
IntentService、HandlerTread、AsyncTack。
知识点分享