Skip to content
Able Blog
Home
Others
  • Home
      • 学习笔记
          • Android
            • 简历_赵思琦_Android_5年经验
                • Handler
                  • 01. handler整体架构方案原理
                    • 02. Message源码分析
                      • 03. Looper源码分析
                        • Looper类说明
                          • API 实现说明
                            • 属性
                              • sThreadLocal
                                • sMainLooper
                                  • 初始化调用链
                                  • ThreadLocal是什么时候set looper的?
                                    • 注释中提到在调用此方法后调用loop(), 为什么?
                                      • loop()
                                      • 调用quit()结束looper, 是如何实现的?
                                        • 阶段总结
                                        • 04. ThreadLocal的使用及源码解析文章
                                          • 05. MessageQueue源码解析
                                            • 06. Handler源码解析
                                              • 07. 源码阅读总结
                                                • 08. Carson Handler总结的机制源码解析
                                                  • 09. handler 内存泄漏的原因

                                              03. Looper源码分析

                                              author iconAblecalendar icon2022年4月13日category icon
                                              • Android
                                              tag icon
                                              • Handler
                                              • 学习笔记
                                              word icon约 663 字

                                              此页内容
                                              • Looper类说明
                                              • API 实现说明
                                              • 属性
                                              • sThreadLocal
                                              • sMainLooper
                                                • 初始化调用链
                                              • ThreadLocal是什么时候set looper的?
                                              • 注释中提到在调用此方法后调用loop(), 为什么?
                                                • loop()
                                              • 调用quit()结束looper, 是如何实现的?
                                              • 阶段总结

                                              # 03. Looper源码分析

                                              # Looper类说明

                                              用于为线程运行消息循环的类。 默认情况下,线程没有与之关联的消息循环; 要创建一个,请在要运行循环的线程中调用 {@link #prepare},然后 {@link #loop} 让它处理消息,直到循环停止。 <p>与消息循环的大多数交互是通过 {@link Handler} 类进行的。 <p>这是一个Looper线程实现的典型例子,利用{@link #prepare}和{@link #loop}的分离来创建一个初始的Handler来与Looper进行通信。

                                              # API 实现说明

                                              此类包含设置和管理基于 MessageQueue 的事件循环所需的代码。 影响队列状态的 API 应该在 MessageQueue 或 Handler 上定义,而不是在 Looper 本身上定义。 例如,空闲处理程序线程、循环和退出是在循环器上定义的。

                                              # 属性

                                              static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
                                              private static Looper sMainLooper;  // guarded by Looper.class
                                              private static Observer sObserver;
                                              final MessageQueue mQueue;
                                              final Thread mThread;
                                              
                                              1
                                              2
                                              3
                                              4
                                              5

                                              # sThreadLocal

                                              Looper数据与线程绑定,每个线程下对应一个Looper。

                                              # sMainLooper

                                              # 初始化调用链

                                              // MainLooper由Android环境创建,不用手动调用这个函数。 prepareMainLooper()已弃用 <-- myLooper() <-- sThreadLocal.get()

                                              使用getMainLooper()可直接获取MainLoopr引用

                                              # ThreadLocal是什么时候set looper的?

                                              //将当前线程初始化为looper。 这使您有机会创建处理程序,然后在实际开始循环之前引用此循环器。 请务必在调用此方法后调用 {@link #loop()},并通过调用 {@link #quit()} 结束它。

                                              prepare(boolean quitAllowed) <-- prepare()

                                              prepare实际上是将当前Looper绑定在所在线程上。 或者说 创建与当前线程相关的Looper.

                                              # 注释中提到在调用此方法后调用loop(), 为什么?

                                              调用此方法循环处理MessageQueue中的消息. 怎么做的?

                                              # loop()

                                               final Looper me = myLooper(); //获取当前线程looper
                                               
                                                 for (;;) {
                                                          if (!loopOnce(me, ident, thresholdOverride)) {
                                                              return;
                                                          }
                                                      }
                                                      
                                                      
                                              * 轮询并传递单个消息,如果外部循环应该继续,则返回 true。
                                               private static boolean loopOnce(final Looper me,
                                                          final long ident, final int thresholdOverride)  方法
                                              
                                              //循环从MessageQueue中获取Message,读取完毕,不再有数据,返回false,loop()方法跳出
                                                   Message msg = me.mQueue.next(); // might block
                                                  if (msg == null) {
                                                      // No message indicates that the message queue is quitting.
                                                      return false;
                                                  }
                                                  ...
                                                  msg.target.dispatchMessage(msg); //调用Handler.dispatchMessage
                                                  ...
                                                  //回收message对象
                                                  msg.recycleUnchecked();
                                              
                                              
                                              1
                                              2
                                              3
                                              4
                                              5
                                              6
                                              7
                                              8
                                              9
                                              10
                                              11
                                              12
                                              13
                                              14
                                              15
                                              16
                                              17
                                              18
                                              19
                                              20
                                              21
                                              22
                                              23
                                              24
                                              25

                                              # 调用quit()结束looper, 是如何实现的?

                                              ??

                                              # 阶段总结

                                              Message 链表结构数据类 可以使用obtain()创建和复用Message对象。 Looper创建ThreadLocal<Looper>存储与线程关联的Looper实例。 在Looper.prepare()中创建,并使用ThreadLocal.set。

                                              Looper.loop() 循环调用MessageQueue中的next方法。全部取出后跳出方法。 每次取出Message对象时都会回收至对象池。

                                              edit icon编辑此页open in new window
                                              上次编辑于: 2022/4/17 23:10:35
                                              贡献者: zsqan
                                              上一页
                                              02. Message源码分析
                                              下一页
                                              04. ThreadLocal的使用及源码解析文章
                                              默认页脚
                                              Copyright © 2022 Able