从架构师的角度分析Android-Handler-源码的正确姿势，阿里牛逼

// 2. 若为初次Looper.prepare()，则创建Looper对象 & 存放在ThreadLocal变量中
// 注：Looper对象是存放在Thread线程里的
// 源码分析Looper的构造方法->>分析a
}

/**

• 分析a：Looper的构造方法
  **/

private Looper(boolean quitAllowed) {

mQueue = new MessageQueue(quitAllowed);
// 1. 创建1个消息队列对象（MessageQueue）
// 即 当创建1个Looper实例时，会自动创建一个与之配对的消息队列对象（MessageQueue）

mRun = true;
mThread = Thread.currentThread();
}

/**

• 源码分析2：Looper.prepareMainLooper()
• 作用：为 主线程（UI线程） 创建1个循环器对象（Looper），同时也生成了1个消息队列对象（MessageQueue）
• 注：该方法在主线程（UI线程）创建时自动调用，即 主线程的Looper对象自动生成，不需手动生成
  */
  // 在Android应用进程启动时，会默认创建1个主线程（ActivityThread，也叫UI线程）
  // 创建时，会自动调用ActivityThread的1个静态的main（）方法 = 应用程序的入口
  // main（）内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象

/**

• 源码分析：main（）
  **/
  public static void main(String[] args) {
  … // 仅贴出关键代码

Looper.prepareMainLooper();
// 1. 为主线程创建1个Looper对象，同时生成1个消息队列对象（MessageQueue）
// 方法逻辑类似Looper.prepare()
// 注：prepare()：为子线程中创建1个Looper对象

ActivityThread thread = new ActivityThread();
// 2. 创建主线程

Looper.loop();
// 3. 自动开启 消息循环 ->>下面将详细分析

}

总结：

• 创建主线程时，会自动调用ActivityThread的1个静态的main（）；而main（）内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象，同时也会生成其对应的MessageQueue对象

1.即 主线程的Looper对象自动生成，不需手动生成；而子线程的Looper对象则需手动通过Looper.prepare()创建
2.在子线程若不手动创建Looper对象 则无法生成Handler对象

• 根据Handler的作用（在主线程更新UI），故Handler实例的创建场景 主要在主线程
• 生成Looper & MessageQueue对象后，则会自动进入消息循环：Looper.loop（），即又是另外一个隐式操作。

步骤1前的隐式操作2：消息循环

此处主要分析的是Looper类中的loop（）方法

/**

• 源码分析： Looper.loop()
• 作用：消息循环，即从消息队列中获取消息、分发消息到Handler
• 特别注意：

•   a. 主线程的消息循环不允许退出，即无限循环
  

•   b. 子线程的消息循环允许退出：调用消息队列MessageQueue的quit（）
  

*/
public static void loop() {

…// 仅贴出关键代码

// 1. 获取当前Looper的消息队列
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException(“No Looper; Looper.prepare() wasn’t called on this thread.”);
}
// myLooper()作用：返回sThreadLocal存储的Looper实例；若me为null 则抛出异常
// 即loop（）执行前必须执行prepare（），从而创建1个Looper实例

final MessageQueue queue = me.mQueue;
// 获取Looper实例中的消息队列对象（MessageQueue）

// 2. 消息循环（通过for循环）
for (;😉 {

// 2.1 从消息队列中取出消息
Message msg = queue.next();
if (msg == null) {
return;
}
// next()：取出消息队列里的消息
// 若取出的消息为空，则线程阻塞
// ->> 分析1

// 2.2 派发消息到对应的Handler
msg.target.dispatchMessage(msg);
// 把消息Message派发给消息对象msg的target属性
// target属性实际是1个handler对象
// ->>分析2

// 3. 释放消息占据的资源
msg.recycle();
}
}

/**

• 分析1：queue.next()
• 定义：属于消息队列类（MessageQueue）中的方法
• 作用：出队消息，即从 消息队列中 移出该消息
  */
  Message next() {

…// 仅贴出关键代码

// 该参数用于确定消息队列中是否还有消息
// 从而决定消息队列应处于出队消息状态 or 等待状态
int nextPollTimeoutMillis = 0;

for (;😉 {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}

// nativePollOnce方法在native层，若是nextPollTimeoutMillis为-1，此时消息队列处于等待状态　
nativePollOnce(ptr, nextPollTimeoutMillis);

synchronized (this) {

final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;

// 出队消息，即 从消息队列中取出消息：按创建Message对象的时间顺序
if (msg != null) {
if (now < msg.when) {
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// 取出了消息
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 {

// 若 消息队列中已无消息，则将nextPollTimeoutMillis参数设为-1
// 下次循环时，消息队列则处于等待状态
nextPollTimeoutMillis = -1;
}

…
}
…
}
}// 回到分析原处

/**

• 分析2：dispatchMessage(msg)
• 定义：属于处理者类（Handler）中的方法
• 作用：派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作
  */
  public void dispatchMessage(Message msg) {

// 1. 若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息
// 则执行handleCallback(msg)，即回调Runnable对象里复写的run（）
// 上述结论会在讲解使用“post（Runnable r）”方式时讲解
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}

// 2. 若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息（即此处需讨论的）
// 则执行handleMessage(msg)，即回调复写的handleMessage(msg) ->> 分析3
handleMessage(msg);

}
}

/**

• 分析3：handleMessage(msg)
• 注：该方法 = 空方法，在创建Handler实例时复写 = 自定义消息处理方式
  **/
  public void handleMessage(Message msg) {
  … // 创建Handler实例时复写
  }

总结：

• 消息循环的操作 = 消息出队 + 分发给对应的Handler实例

• 分发给对应的Handler的过程：根据出队消息的归属者通过dispatchMessage(msg)进行分发，最终回调复写的handleMessage(Message msg)，从而实现 消息处理 的操作

• 特别注意：在进行消息分发时

（dispatchMessage(msg)

，会进行1次发送方式的判断：

若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息，则直接回调Runnable对象里复写的run（）
若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息，则回调复写的handleMessage(msg)
至此，关于步骤1的源码分析讲解完毕

步骤2：创建消息对象

/**

• 具体使用
  */
  Message msg = Message.obtain(); // 实例化消息对象
  msg.what = 1; // 消息标识
  msg.obj = “AA”; // 消息内容存放

/**

• 源码分析：Message.obtain()
• 作用：创建消息对象
• 注：创建Message对象可用关键字new 或 Message.obtain()
  */
  public static Message obtain() {

// Message内部维护了1个Message池，用于Message消息对象的复用
// 使用obtain（）则是直接从池内获取
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize–;
return m;
}
// 建议：使用obtain（）”创建“消息对象，避免每次都使用new重新分配内存
}
// 若池内无消息对象可复用，则还是用关键字new创建
return new Message();

}

步骤3：在工作线程中 发送消息到消息队列中

多线程的实现方式：AsyncTask、继承Thread类、实现Runnable

/**

• 具体使用
  */

mHandler.sendMessage(msg);

/**

• 源码分析：mHandler.sendMessage(msg)
• 定义：属于处理器类（Handler）的方法
• 作用：将消息 发送 到消息队列中（Message ->> MessageQueue）
  */
  public final boolean sendMessage(Message msg)

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）

最后

我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了5、6年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。

其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。

不断奔跑，你就知道学习的意义所在！

《Android高级架构师面试指导+2021大厂面试真题》免费领取

们也没有太多想法。

其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。

不断奔跑，你就知道学习的意义所在！

[外链图片转存中…(img-OS6HKEc3-1711078934148)]

《Android高级架构师面试指导+2021大厂面试真题》免费领取

[外链图片转存中…(img-zuLvn1bL-1711078934148)]