1、概述
在分析Handler原理时少不了Looper、Message的介绍,它们共同实现Android异步消息处理。
那Handler、Looper、Message是怎样实现不同线程之间的消息处理的呢?
简单的说就是:Handler将Message发送到Looper内部的一个消息队列MessageQueue中,Looper内有个无线循环,不断的在MessageQueue中获取msg,将msg回调给Handler处理,MessageQueue为空时,线程阻塞等待。
2、源码走读
2.1、Handler消息发送
首先从Handler发送消息着手,Handler提供给外部使用的发送消息发送有以下多个:
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean postAtTime(Runnable r, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}
public final boolean postDelayed(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
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);
}
方法虽然较多,不难发现它们最终都会进入54行的这个sendMessageAtTime(...)方法,该方法56行的mQueue在Hanlder构造方法中获得,这里贴出代码量较少的一个构造方法:
public Handler(Looper looper, Callback callback, boolean async)
{
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
可以看到mQueue是从looper中获取到的。回到上面的
sendMessageAtTime(...)方法,方法在对mQueue判空后,调用了enqueueMessage(...)方法,并将在Looper中获取到的mQueue传入。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)
{
msg.target = this;
if (mAsynchronous)
{
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
这个方法很简单,先将Handler绑定在msg的target上(这里其实就是为msg加上一个标记,当消息处理时能够通过这个标记回到之前的Handler内处理),然后将msg加入到Looper内的messageQueue中。
到这里Handler的消息发送过程也就走读完了,消息已经发送到Looper的messageQueue中,接下来就看一下MessageQueue插入message的工作流程。
2.2、MessageQueue如何插入message
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;
}
第2行判断msg是否绑定了handler,若没有直接抛出异常。第5行判断msg是否正在插入处理,若正在处理直接抛出异常。第18行将msg标记为正在插入处理。22行:若当前队列没有消息||当前插入消息为即时消息||插入消息执行时间小于当前准备处理的消息,则将插入消息为优先级最高的消息,插入到队列最前端记录为当前准备处理消息。若22行条件不满足,则在33行循环现有队列,直到36行找到插入位置,在43-44行插入到队列中去。到这里就完成了message插入到MessageQueue的流程。下面接着看持有MessageQueue的Looper的工作流程。
2.3、Looper
Looper最重要的两个方法为prepare()和loop(),这两个方法在Activity创建时就已被调用,所以我们使用中可能并未手动调用。首先看下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));
}
这里sThreadLoacal为ThreadLoacal对象,它用来在当前线程中保存一个Looper对象,第8行先判断sThreadLoacal是否已有looper对象,若有则直接抛出异常,这也就保证了一个线程中只能有一个looper对象。第12行sThreadLoacal未保存looper时,新建一个looper并保存在sThreadLoacal。
Looper的构造方法如下:
private Looper(boolean quitAllowed)
{
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
在构造方法中创建了久违的MessageQueue,由于一个线程中只有一个Looper,所以一个线程中也只有一个MessageQueue。
下面看一下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();
}
}
第2行myLooper()方法为从
sThreadLoacal中获取looper对象,第3行若获取到的looper为空则直接抛出异常。第6行从looper中拿出messageQueue对象。13行进入进入无线循环。14行从队列中获取一条消息。15行获取到的消息为空时,也就是队列中没有消息时,跳出循环。32行将消息发送给指定的target,这里的target也就是上面绑定在message上的handler。
2.1、Handler消息接收
上面message回到了发送它的Handler的dispatchMessage(msg):
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
第3行首先判断msg是否添加了callback,若添加了则优先执行hanldleCallback()
private static void handleCallback(Message message) { message.callback.run(); }即直接执行messge的回调。
若msg未添加callback,则在第6行判断Handler是否添加了callback(handler构造时可添加callback),若Handler添加了callback则将msg在第7行回调给handler的callback。
若handler也未添加callback或第7行回调失败,则执行handlerMessage(msg)方法:
public void handleMessage(Message msg) {
}
而
handlerMessage(msg
)本身为一个空实现的方法,这时就需要使用者复写该方法,在里面对msg做具体处理了,一般使用时都会根据不同的msg.what来区分不同的消息,如下:
private Handler mHandler = new Handler()
{
public void handleMessage(android.os.Message msg)
{
switch (msg.what)
{
case value:
break;
default:
break;
}
}
};
到这里handler的发送消息的流程就已基本走完了。
3、总结
1、在指定线程创建handler,之后handler收到的消息都会在该线程中;
2、handler在其他线程将消息发送给当前线程的Looper的MessageQueue中去;
3、一个线程只有一个Looper,同时也就只有一个MessageQueue;
4、MessageQueue按msg的时间优先级将msg插入到合理位置;
5、looper无线循环取出msg,并将msg发回msg绑定的handler;