Android的消息机制
Android消息机制概述
Android的消息机制主要是指Handler的运行机制以及Handler所附带的MessageQueue和Looper的工作过程.
- 一个
Thread包含一个Looper - 一个
Looper包含一个MessageQueue - 一个
Handler包含一个Looper和一个Messagequeue(和Looper中的是同一个)
Handler通过sendMessage()或post()方法将Message放到MessageQueue中， 然后Looper.loop()方法不停的循环从MessageQueue中取Message，成功取出后，通过在loop()中调用message.target.dispatchMessage()方法(message.target其实就是发送Message的Handler)来执行Handler.handleMessage方法.
总结:跨线程的关键是Handler中的Looper是定义Handler时所在Thread的Looper, MessageQueue也是这个Thread的Looper中的MessageQueue，所以之后我们不管在哪个线程调用Handler.sendMessage()方法，Message都会被发送到定义Handler时的Looper的MessageQueue中, 因此Handler.dispatchMessage()都是在定义Handler时的那个线程中执行的。
ThreadLocal
ThreadLocal是一个线程内部的数据存储类， 它可以保证， 同一个变量， 在不同的线程中， 使用的都是不同的副本。
Looper就是利用ThreadLocal来保证它在每个Thread中都是独立存在的。
private ThreadLocal<Boolean> mBooleanThreadLocal = new ThreadLocal<Boolean>();
mBooleanThreadLocal.set(true);
Log.d(TAG, "MainThread mBooleanThreadLocal=" + mBooleanThreadLocal.get());
new Thread("Thread1"){
@Override
public void run(){
mBooleanThreadLocal.set(false);
Log.d(TAG, "Thread1 mBooleanThreadLocal=" + mBooleanThreadLocal.get());
}
new Thread("Thread1"){
@Override
public void run(){
Log.d(TAG, "Thread2 mBooleanThreadLocal=" + mBooleanThreadLocal.get());
}
}
输出结果为:
MainThread mBooleanThreadLocal=true
Thread1 mBooleanThreadLocal=false
Thread2 mBooleanThreadLocal=null
从上面的结果中可以发现， 虽然看起来主线程和Thread1、Thread2使用的都是同一个ThreadLocal对象， 但是他们其实操作的都是不同的对象。
具体的实现原理可以参考这篇文章
MessageQueue工作原理
MessageQueue主要包含两种操作：插入(enqueueMessage())和读取(next()).
MessageQueue内部实现并不是一个队列， 而是一个单链表.
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;
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;
}
从enqueueMessage()的实现可以看出它的主要操作就是单链表的插入。
Message next() {
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
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()方法其实是一个无限循环的方法，如果消息队列没有消息，那么next()方法会一直堵塞在那里。当有新消息来时，next()方法会返回这条消息并将其从单链表中移除。
Looper工作原理
- 我们在自定义的
Thread中通过Looper.prepare()来进行初始化Thread本身的Looper，通过调用Looper.loop()方法来循环取出MessageQueue中的Message
Handler在构造方法中从通过Looper.myLooper()方法取出当前Thread的Looper(在Looper.prepare()中set到sThreadLocal中的Looper)new Thread("Thread#1") { @Override public void run(){ Looper.prepare(); Handler handler = new Handler(); Looper.loop(); } } 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)); } 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; } public static void loop() { final Looper me = myLooper(); final MessageQueue queue = me.mQueue; for (;;) { Message msg = queue.next(); // might block if (msg == null) { // No message indicates that the message queue is quitting. return; } try { msg.target.dispatchMessage(msg); end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis(); } finally { if (traceTag != 0) { Trace.traceEnd(traceTag); } } //省略... } } -
Looper会在它的构造方法中初始化属于它的MessageQueueprivate Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); } -
Looper提供了quit()和quitSafely()两个方法来退出, 两者的区别是quit()会直接退出，quitSafely()会把MessageQueue()已有的消息处理完后再退出 - 在子线程中使用完
Looper后需要调用quit()方法来退出， 否则那个子线程就会一直处于等待状态public void quit() { mQueue.quit(false); }
Handler工作原理
Handler的主要工作包含发送和接收过程。消息的发送可以通过post系列方法以及sendMessage方法实现，但是post的一系列方法最终是通过sendMessage系列方法实现的。
sendMessage系列方法发送一条消息的典型过程如下所示：
public final boolean sendMessage(Message msg){
return sendMessageDelayed(msg, 0);
}
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);
}
可以发现Handler发送消息的过程仅仅是向MessageQueue插入了一条消息，MessageQueue通过next方法就会将这条Message返回给Looper，最终消息由Looper交由Handler处理，即Handler的dispatchMessage方法会被调用，这时Handler就进入了消息处理的阶段。dispatchMessage()如下所示：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
首先，检查msg.callback是否为null， 不为null就通过handleCallback()来处理消息。
其次，如果mCallback 不为null，就通过mCallback.handleMessage(msg)来处理消息。
最后，调用最常见的handleMessage(msg)来处理消息。
-
msg.callback就是我们调用Handler的post系列方法所传递的Runnable参数。 -
mCallback是一个接口，Handler提供了一个构造方法，使我们可以传递一个Callback作为参数，这样我们就不用重写Handler了public interface Callback { public boolean handleMessage(Message msg); } Handler handler = new Handler(callback);
