4.2消息机制流程分析
目录介绍
- 01.Handler发送消息
- 02.Looper轮训操作
- 03.MessageQueue消息队列
- 04.MessageQueue传递消息给Handler
- 05.Handler接收消息并处理
- 06.消息机制总结分享
01.Handler发送消息
- Handler 发送消息的形式主要有以下几种形式,其最终调用的都是
sendMessageAtTime()
方法public final boolean sendMessage(Message msg){ return sendMessageDelayed(msg, 0); } public final boolean post(Runnable r){ return sendMessageDelayed(getPostMessage(r), 0); } public final boolean sendMessageDelayed(Message msg, long delayMillis){ if (delayMillis < 0) { delayMillis = 0; } return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); }
- 可以看到
sendMessageAtTime()
方法中需要一个已初始化的MessageQueue
类型的全局变量mQueue
,否则程序无法继续走下去。博客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); }
- 而
mQueue
变量是在构造函数中进行初始化的,且mQueue
是成员常量,这说明Handler
与MessageQueue
是一一对应的关系,不可更改
- 而
- 然后看下Handler构造方法
- 如果构造函数没有传入
Looper
参数,则会默认使用当前线程关联的Looper
对象,mQueue
需要依赖于从Looper
对象中获取。 - 如果
Looper
对象为 null ,则会直接抛出异常,且从异常信息Can't create handler inside thread that has not called Looper.prepare()
中可以看到,在向Handler
发送消息前,需要先调用Looper.prepare()
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; }
- 如果构造函数没有传入
02.Looper轮训操作
- 在
Looper
类中,可以看到,myLooper()
方法是从sThreadLocal
对象中获取Looper
对象的。sThreadLocal
对象又是通过prepare(boolean)
来进行赋值的,且该方法只允许调用一次,一个线程只能创建一个 Looper 对象,否则将抛出异常。
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); public static @Nullable Looper myLooper() { return sThreadLocal.get(); } 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)); }
- 此处除了因为
prepare(boolean)
多次调用会抛出异常导致无法关联多个 Looper 外。- Looper 类的构造函数也是私有的,且在构造函数中还初始化了一个线程常量
mThread
,这都说明了 Looper 只能关联到一个线程,且关联之后不能改变。
final Thread mThread; private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }
- Looper 类的构造函数也是私有的,且在构造函数中还初始化了一个线程常量
- 那么
Looper.prepare(boolean)
方法又是在哪里调用的呢?- 查找该方法的所有引用,可以发现在
Looper
类中有如下方法,从名字来看,可以猜测该方法是由主线程来调用的,查找其引用。博客
public static void prepareMainLooper() { prepare(false); synchronized (Looper.class) { if (sMainLooper != null) { throw new IllegalStateException("The main Looper has already been prepared."); } sMainLooper = myLooper(); } }
- 查找该方法的所有引用,可以发现在
- 定位到
ActivityThread
类的main()
方法- 看到
main()
函数的方法签名,可以知道该方法就是一个应用的起始点,即当应用启动时, 系统就自动为我们在主线程做好了Handler
的初始化操作, 因此在主线程里我们可以直接使用Handler
- 如果是在子线程中创建
Handler
,则需要我们手动来调用Looper.prepare()
方法
public static void main(String[] args) { ··· Looper.prepareMainLooper(); ActivityThread thread = new ActivityThread(); thread.attach(false); if (sMainThreadHandler == null) { sMainThreadHandler = thread.getHandler(); } if (false) { Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread")); } // End of event ActivityThreadMain. Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); Looper.loop(); throw new RuntimeException("Main thread loop unexpectedly exited"); }
- 看到
03.MessageQueue消息队列
- 既然
Looper
对象已经由系统来为我们初始化好了,那我们就可以从中得到mQueue
对象。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()"); } //获取 MessageQueue 对象 mQueue = mLooper.mQueue; mCallback = callback; mAsynchronous = async; }
mQueue
又是在Looper
类的构造函数中初始化的,且mQueue
是Looper
类的成员常量,这说明 Looper 与 MessageQueue 是一一对应的关系private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }
sendMessageAtTime()
方法中在处理Message
时,最终调用的是enqueueMessage()
方法- 当中,需要注意
msg.target = this
这句代码,target 对象指向了发送消息的主体,即 Handler 对象本身。 - 即由 Handler 对象发给 MessageQueue 的消息最后还是要交由 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) { //target 对象指向的也是发送消息的主体,即 Handler 对象 //即由 Handler 对象发给 MessageQueue 的消息最后还是要交由 Handler 对象本身来处理 msg.target = this; if (mAsynchronous) { msg.setAsynchronous(true); } return queue.enqueueMessage(msg, uptimeMillis); }
- 因为存在多个线程往同一个 Loop 线程的 MessageQueue 中插入消息的可能,所以
enqueueMessage()
内部需要进行同步。 - 可以看出 MessageQueue 内部是以链表的结构来存储 Message 的(Message.next),根据 Message 的延时时间的长短来将决定其在消息队列中的位置。博客
- 当中,需要注意
04.MessageQueue传递消息给Handler
4.1 MessageQueue消息队列逻辑
- mMessages 代表的是消息队列中的第一条消息
- 如果 mMessages 为空,说明消息队列是空的,或者 mMessages 的触发时间要比新消息晚,则将新消息插入消息队列的头部;
- 如果 mMessages 不为空,则寻找消息列队中第一条触发时间比新消息晚的非空消息,并将新消息插到该消息前面
- 到此,一个按照处理时间进行排序的消息队列就完成了,后边要做的就是从消息队列中依次取出消息进行处理
boolean enqueueMessage(Message msg, long when) { //Message 必须有处理者 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; }
4.2 MessageQueue读取Message回调给Handler
- 再看下 MessageQueue 是如何读取 Message 并回调给 Handler 的。
- 在 MessageQueue 中消息的读取其实是通过内部的
next()
方法进行的,next()
方法是一个无限循环的方法,如果消息队列中没有消息,则该方法会一直阻塞,当有新消息来的时候next()
方法会返回这条消息并将其从单链表中删除。博客
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; } // Process the quit message now that all pending messages have been handled. if (mQuitting) { dispose(); return null; } // If first time idle, then get the number of idlers to run. // Idle handles only run if the queue is empty or if the first message // in the queue (possibly a barrier) is due to be handled in the future. if (pendingIdleHandlerCount < 0 && (mMessages == null || now < mMessages.when)) { pendingIdleHandlerCount = mIdleHandlers.size(); } if (pendingIdleHandlerCount <= 0) { // No idle handlers to run. Loop and wait some more. mBlocked = true; continue; } if (mPendingIdleHandlers == null) { mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)]; } mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers); } // Run the idle handlers. // We only ever reach this code block during the first iteration. for (int i = 0; i < pendingIdleHandlerCount; i++) { final IdleHandler idler = mPendingIdleHandlers[i]; mPendingIdleHandlers[i] = null; // release the reference to the handler boolean keep = false; try { keep = idler.queueIdle(); } catch (Throwable t) { Log.wtf(TAG, "IdleHandler threw exception", t); } if (!keep) { synchronized (this) { mIdleHandlers.remove(idler); } } } // Reset the idle handler count to 0 so we do not run them again. pendingIdleHandlerCount = 0; // While calling an idle handler, a new message could have been delivered // so go back and look again for a pending message without waiting. nextPollTimeoutMillis = 0; } }
- 在 MessageQueue 中消息的读取其实是通过内部的
next()
方法又是通过Looper
类的loop()
方法来循环调用的,而loop()
方法也是一个无限循环,唯一跳出循环的条件就是queue.next()
方法返回为null ,细心的读者可能已经发现了,loop()
就是在ActivityThread
的main()
函数中调用的- 因为
next()
方法是一个阻塞操作,所以当没有消息也会导致loop()
方法一只阻塞着,而当 MessageQueue 一中有了新的消息,Looper 就会及时地处理这条消息并调用Message.target.dispatchMessage(Message)
方法将消息传回给 Handler 进行处理/** * Run the message queue in this thread. Be sure to call * {@link #quit()} to end the 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 slowDispatchThresholdMs = me.mSlowDispatchThresholdMs; final long traceTag = me.mTraceTag; if (traceTag != 0 && Trace.isTagEnabled(traceTag)) { Trace.traceBegin(traceTag, msg.target.getTraceName(msg)); } final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis(); final long end; try { msg.target.dispatchMessage(msg); end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis(); } finally { if (traceTag != 0) { Trace.traceEnd(traceTag); } } if (slowDispatchThresholdMs > 0) { final long time = end - start; if (time > slowDispatchThresholdMs) { Slog.w(TAG, "Dispatch took " + time + "ms on " + Thread.currentThread().getName() + ", h=" + msg.target + " cb=" + msg.callback + " msg=" + msg.what); } } 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(); } }
05.Handler接收消息并处理
- 看下 Handler 对象处理消息的方法
/** * Handle system messages here. */ 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 ,则调用 callback 对象的run()
方法,该 callback 实际上就是一个 Runnable 对象,对应的是 Handler 对象的post()
方法private static void handleCallback(Message message) { message.callback.run(); } public final boolean post(Runnable r){ return sendMessageDelayed(getPostMessage(r), 0); } private static Message getPostMessage(Runnable r) { Message m = Message.obtain(); m.callback = r; return m; }
- 如果
mCallback
不为 null ,则通过该回调接口来处理消息,如果在初始化 Handler 对象时没有通过构造函数传入Callback
回调接口,则交由handleMessage(Message)
方法来处理消息,我们一般也是通过重写 Handler 的handleMessage(Message)
方法来处理消息
- 如果
06.消息机制总结分享
- 一、在创建 Handler 实例时要么为构造函数提供一个 Looper 实例,要么默认使用当前线程关联的 Looper 对象,如果当前线程没有关联的 Looper 对象,则会导致抛出异常
- 二、Looper 与 Thread ,Looper 与 MessageQueue 都是一一对应的关系,在关联后无法更改,但 Handler 与 Looper 可以是多对一的关系
- 三、Handler 能用于更新 UI 有个前提条件:Handler 与主线程关联在了一起。在主线程中初始化的 Handler 会默认与主线程绑定在一起,所以此后在处理 Message 时,
handleMessage(Message msg)
方法的所在线程就是主线程,因此 Handler 能用于更新 UI - 四、可以创建关联到另一个线程 Looper 的 Handler,只要本线程能够拿到另外一个线程的 Looper 实例
其他介绍
01.关于博客汇总链接
02.关于我的博客
- github:https://github.com/yangchong211
- 知乎:https://www.zhihu.com/people/yczbj/activities
- 简书:http://www.jianshu.com/u/b7b2c6ed9284
- csdn:http://my.csdn.net/m0_37700275
- 喜马拉雅听书:http://www.ximalaya.com/zhubo/71989305/
- 开源中国:https://my.oschina.net/zbj1618/blog
- 泡在网上的日子:http://www.jcodecraeer.com/member/content_list.php?channelid=1
- 邮箱:yangchong211@163.com
- 阿里云博客:https://yq.aliyun.com/users/article?spm=5176.100- 239.headeruserinfo.3.dT4bcV
- segmentfault头条:https://segmentfault.com/u/xiangjianyu/articles
- 掘金:https://juejin.im/user/5939433efe88c2006afa0c6e