很多人在面试的时候都会被面试官问道Handler、Message、MessageQueue和Looper之间的关系,以及是如何工作的,因为Handler机制也是android的消息机制,是重点,所以今天我们就从android的源码部分,来更加深入的了解一下android是如何工作的。
首先先说一下Handler、Message、MessageQueue和Looper之间的关系:
1.MessageQueue:消息队列,里面有若干和待处理的消息(Message)
2.Message:消息,通过Handler发送,以链式的队列在MessageQueue中
3.Looper:消息的轮询器,是一个死循环,如果有消息,则将消息取出,交给Handler来处理(一个线程只可以产生一个Looper对象,由它来管理此线程里的MessageQueue)
4.Handler:消息的发送者,将消息(Message)发送出去,插入到MessageQueue里,和处理Looper从MessageQueue取出来的消息
好了,这些大概就是面试者在面对面试官提问的时候回答的答案,可是仅仅是智能说出来,但并不知道他们之间具体是怎么协调工作的,下面看代码。
首先现看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));
}
首先看 第6行的if语句,其实就是判断该线程是否还存在其他的Looper,如果已经有Looper,则会抛出异常,所以一个线程只能存在一个Looper。然后看 第9行的new Looper,点击进去:
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
我们看到,MessageQueue是在这里new出来的,接下来有了消息队列,当我们自己发送消息,也就是我们常用的handler.sendEmptyMessage()或者handler.sendMessage(),这里以sendEmptyMessage为例,看源码:
public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}
返回了sendEmptyMessageDelayed方法,继续往下跟:
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
第二行要注意,这里使用的是Message.obtain()来创建一个Message,这也是官方推荐的做法,尽量不要去直接new一个。然后接着往下跟:
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
最后到了sendMessageAtTime这个方法:
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);
}
这个方法首先会判断消息队列是否为null,不为null时执行enqueueMessage方法,继续点进去:
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
注意最后一行,调用了MessageQueue的一个方法 queue.enqueueMessage(msg, uptimeMillis),这个方法的作用是将Message插入到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;
}
首先看
第2行,这个msg.target是什么呢?其实就是handler,判断handler不为null继续往下执行。然后看
第20、25、26行,这三行的逻辑大概看一下就懂了,就是各种赋值message,来回倒换:先把mMessages赋值给p,然后把赋值给msg.next,这个msg.next就是接下来要处理的message,然后再把msg赋值给mMessages,完成一次传导。注意看上面的if语句,判断了一下when==0,和when < p.when,这条if语句的作用就是优先对比Message之间的时间,时间小的先执行,有点像“插队”的性质。接下来
看第33行,一个for (;;),相当于就是个while(true)的无限循环,我记着低版本的android源码里一直用的是while(true),后来从XX版以后才变成的for (;;),具体是什么版后扁的我也没有去查阅,作用是一样的,有兴趣的可以自己去查一下,回归主题,for (;;)死循环一直在不停的取出消息,quit()方法的时候,才会使其进入等待状态,quit()的源码我就不附了,其实就是把message置为null来阻塞线程,下面继续讲重点,我们讲完了插入消息,就该讲讲取出消息,那么是在哪取出消息的呢?记性好的就会马上想到之前我们说到的Looper,它的作用就是从MessageQueue里取出Message,然后交给Handler处理,那么我满看一下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
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
msg.target.dispatchMessage(msg);
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();
}
}
看最主要的 第13行,又一个死循环,没错,这个循环的作用就是不断地取出消息,只有当msg == null的时候才会被堵塞,看第14行,调用的MessageQueue的next()方法,这个方法的作用就是取出并交给Handler,然后从消息队列里删除消息,源码不附了,有兴趣的可以自己看一下,然后看 第27行,msg.target.dispatchMessage(msg); 这个msg.target就是Handler,下面看Handler的dispathMessage源码:
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
看 第10行,点进去:
public void handleMessage(Message msg) {
}
哎?怎么是空的?这就对了,因为这里的逻辑是我们自己写的,当我们派生一个handler然后send一个message的时候,就是走的这里,也就是说,dispathMessage这个方法就把消息传回给了Handler自己来处理,这样就是一个循环,也就是Android里Handler的机制,也是整个android系统的消息传递机制。
希望喜欢的朋友们留个言!!!