通过源码理解android 中Handler,Message,Looper,MessageQueue之间的关系,之前说到handler机制,都是在网上看到得别人是怎么讲解的,自己就机械的记下来,回来忘了再到网上搜一堆资料看看,对自己本身能力没有太大的提升。纸上得来终觉浅 绝知此事要躬行。开始试着自己阅读源码,进行深入理解一下。
首先分别介绍一些handler,message,Looper,MessageQueue
handler 一般是我们进行异步任务的完成时,通过handler通知主线程更新UI.
Message 是Handler发送的消息内容。
Looper 是一个轮询器负责,负责轮询MessageQueue里面的消息,然后将looper轮询的消息发送到Handler里面,一个Handler是对应一个Looper.
MessgeQueue 存放Message的消息的链表,通过Handler.send。
下面通过源码介绍一下handler发送和接收消息的完整流程就明白他们之间的关系了。
1.创建一个Hanlder
Handler mHandler=new 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 that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
从这里看出两个参数的构造方法中通过 mLooper = Looper.myLooper()获取了一个looper实例,又通过mQueue = mLooper.mQueue;获得了一个MessageQueue实例。每个Handler都会有一个唯一对应的Looper和MessageQueue.
2.handler发送消息
一般我们会通过sendMessage(Message msg)发送消息,而sendMessage是直接调用的sendMessageDelayed
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
sendMessageAtTime方法又调用的sendMessageAtTime,在这里就出现了我们创建handler时获取的MessageQueue实例。
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);
}
下面就是把Message添加到MessageQueue里面
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
msg.target = this;是将当前的Handler赋值给msg.targer,消息发送会用到。这就是一个完整的从消息发送到添加到MessageQueue过程。
有时候我们发送的内容不是一个Message,例如使用的是sendEmptyMessage(int what),他会调用sendEmptyMessageDelayed 内部会帮我们创建一个Message对象。
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
- Looper是如何获取MessageQueue里面的消息并发送给Handler的。
Looper在创建完成后就开始了一个无限for循环,不断的从MessageQueue中取Message。
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.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();
}
}
如果获取的Message为空就return 等待,如果不为空就msg.target.dispatchMessage(msg);将message分发出去,dispatchMessage()是handler中的方法,我们在发送消息的时候将handler赋值给了msg.target.
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
dispatchMessage方法会调用Callback中的方法handleMessage(msg),就是直接发送给了我们创建的handler,也就是在handleMessage方法里接收消息
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
这个handler消息发送到接收的流程就完成了。
我们在理一下最后在理一下思路,
创建一个Handler会调用Handler两个参数的构造方法,两个参数的构造方法会通过mLooper = Looper.myLooper()获取一个looper对象,然后通过mQueue = mLooper.mQueue;获取一个MessageQueue对象,和一个接口回调
mCallback = callback;这个接口就是定义的handlermessage方法。我们进行handler.sendMessage的时候会将Message添加到MessageQueue里面,创建looper时,looper就开始了他的for循环,不断的从MessageQueue中获取方法,Message msg = queue.next()获取消息,如果获取的消息为null,就return,不为空,执行msg.target.dispatchMessage(msg);进行消息的分发,也就是发送到handleMessage方法里面。Msg.target是一个Handler对象,因为我们在enqueueMessage里msg.target = this;将当前的handler赋值给了msg.target.