msg.next = null;
msg.markInUse();
return msg;
}
}
}
}
}
nativePollOnce
是一个本地方法,它会阻塞线程直到下一个有消息来临。这类似于Java中的DelayQueue
,不同点是DelayQueue
是通过优先队列+锁实现的。 在MessageQueue中有一个Message类型的对象mMessage
,它保存着消息队列中最早的一条消息。当阻塞的线程被唤醒时,next()
方法会返回mMessage
,并且mMessage
重新赋值为mMessage.next
。 很容易发现,在消息队列中,所有未读的消息是通过链表的形式来保存的,每一个Message都是链表中的节点,Message#next
指向了链表中的下一个节点。
小结
-
Looper和拥有Looper的线程一一对应,通过ThreadLocal来实现。Looper和消息队列也是一一对应的。
-
Looper.loop()
中是一个死循环,会无限调用对应消息队列的next()
方法来获取下一个消息。 -
消息队列的
next()
方法会调用native方法nativePollOnce
阻塞线程,直到有新的消息来临将其返回。 -
消息队列实质上是以
Message
为节点的单向链表,其头节点为mMessage
。链表是按照Message的触发时间,即msg.when
,从早到晚排序的。
从发送消息开始。使用Handler的post(runnalbe)
、sendMessage(msg)
、sendMessageDelayed(msg, delay)
、Message的sendToTarget()
等等许多方法都可以发送消息。最终,这些方法都会进入Handler#enqueueMessage
方法。
- Handler#enqueueMessage(MessageQueue, Message, long)
enqueueMessage
方法的作用是将Message的target设置为本Handler,然后调用MessageQueue的enqueueMessage
方法。
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
long uptimeMillis) {
msg.target = this;
msg.workSourceUid = ThreadLocalWorkSource.getUid();
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
这个queue
即是Looper.mQueue
,即当前线程的消息队列。在这里,会使用msg.target = this
将Message与当前Handler绑定。 这里的uptimeMillis
是Message预定送达的时间,如果没有设置延迟,那么这个时间是SystemClock.uptimeMillis()
。
- MessageQueue#enqueueMessage(Message, long)
顾名思义,enqueueMessage
表示将新到来的消息入队。 删去了部分,只保留关键代码:
boolean enqueueMessage(Message msg, long when) {
synchronized (this) {
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;
}
这里做了两件事: 一、将这个Message按照传达时间的顺序插入到消息队列中; 二、如果消息队列当前是阻塞的,并且这个消息的传达时间成为了消息队列中最早的一个,那么就将线程唤醒。
当消息入队之后,消息发送的过程就已经完毕了,接下来就是等待取出消息了。
-
MessageQueue#next()
-
Looper#loop()
第1小节提到了,Looper会无限循环从MessageQueue中读取消息。
public static void loop() {
for (;😉 {
Message msg = queue.next(); // might block
try {
msg.target.dispatchMessage(msg);
} // …
}
}
当一个消息msg
到达指定时间并被读取到之后,会调用msg.target.dispatchMessage()
方法;而这个target
对象就是上面Handler#enqueueMessage()
方法中传递进去的Handler。 也就是说,消息被读取到之后,会调用对应Handler的dispatchMessage
方法。
- Handler#dispatchMessage()
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
这里的逻辑很简单,如果这个Handler设置了Callback
的话,就调用handleCallback
回调,否则就调用handleMessage
回调。可以看到,如果设置了Callback的话,Handler的handleMessage
就不生效了,这一点很容易证实。 此时,就完成了从消息发送到消息处理的流程。
小结
- Handler消息的传递流程:
-> Handler#enqueueMessage(MessageQueue, Message, long)
所有发送消息最终调用该方法
-> MessageQueue#enqueueMessage(Message, long)
消息入队
-> MessageQueue#next()
等待消息到时,取出消息
-> Handler#dispatchMessage(msg)
发送消息到对应Handler
-> Handler#handleMessage(msg)
或Handler.Callback#handleCallback(msg)
:处理消息
- Handler相当于一个前台的工具人,只做了发送消息和接收消息的工作,消息处理的主要传递和分发过程都交给了Looper和MessageQueue。
===============================================================================
回到标题中的问题。 从上面的分析中,可以看到,在Looper.loop()
的死循环中,主线程的确是被阻塞了;并且如果没有消息,将会一直阻塞下去——这一点毫无疑问。所以这个问题本身就是不严谨的:得先问是不是,再问为什么。
public static void loop() {
final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
for (;😉 {
Message msg = queue.next(); // might block
try {
msg.target.dispatchMessage(msg);
} // …
}
}
这个问题正确的问法是,为什么主线程Looper中的死循环不会造成ANR/卡顿?
虽然这个问题仍然没有什么逻辑性——死循环和ANR/卡顿似乎并没有什么太大的联系,并且可以说是完全没有关系。要回答这个问题,首先要分析ANR/卡顿的原因,这是一个综合性的问题。
首先要明确的是,卡顿和ANR不是一回事儿。
卡顿指手机不能在肉眼无法察觉的时间内完成一帧的绘制。对于一个60hz的屏幕,每一帧需要在16ms内完成绘制,否则就会丢帧。丢帧越多,卡顿就越严重。卡顿的主要原因是主线程干了太多的事情,导致了16ms之内无法完成一帧的绘制,可能是布局层次太深导致绘图耗费时间长,可能是进行了复杂的运算,还有可能是频繁GC引发卡顿……总之,就是主线程负担太重了。
ANR指的是Application Not Responding,也就是应用无响应。这里ANR特指输入无响应ANR,也就是应用对触摸屏幕或者按键的响应时间超过5秒。也就是说,ANR的发生的必要条件是,需要有输入,也就是用户点击了屏幕之类的,否则是不会发生ANR的。ANR产生的原理比较复杂,当用户点击了屏幕,InputManagerService会通过epoll机制在硬件层面读取到这个事件后,会使用InputDispatcher通过Socket通知对应的ViewRootImple。而ANR是在InputDispatcher.cpp中的handleTargetsNotReadyLocked
函数检测的,在这里,当一个事件分发下去之后,会设置一个超时时间,也就5秒之后;在下一个事件到来时,如果时间大于超时时间,并且上一个事件还没有处理完毕的话,就要走ANR流程了。
当然,究其根本原因,造成ANR的原因很大程度上大致与卡顿是相似的,但是二者是完全不同性质的两个事件。
回到问题上,卡顿是因为出于某种原因导致的绘制时间过长,而ANR的原因是对用户的操作响应超时。 而Looper中的死循环是为了读取消息,要知道Android应用本质上是消息驱动的,不管是卡顿还是ANR,本质上都是对应Handler或者Handler.Callback的handleMessage()
处理消息方法的执行时间太长;而Looper中的死循环是在体系之外的,不在某个Handler的handleMessage()
方法体之中,自然也就不会引起卡顿和ANR了。
2. Handler只能在主线程创建吗?如果不是,那Handler可以在任意线程创建吗?
否。
Handler的作用是作为一个终端发送和处理消息,需要配套的消息队列才能发挥作用。所以,Handler只能在调用了Looper.prepare()
的线程中使用,并且在最后加上Looper.loop()
使其生效。如果在没有调用Looper.prepare()
的线程创建Handler,会出现 “Can’t create handler inside thread that has not called Looper.prepare()” 的错误。
同时,这个线程的所有代码都要写在Looper.prepare()
和Looper.loop()
之间,因为Looper.loop()
会阻塞线程,后面的代码没法执行到。
3. View.post()方法和Handler.post()是一样的吗?
View#post()
方法本质上也是调用了Handler#post()
,这个Handler保存在View的mAttachInfo
中,通过父容器调用View的dispatchAttachedToWindow(attachInfo, visibility)
方法传递过来。 这个Handler最终是指向 ViewRootImpl中的mHandler
对象,类型是继承自Handler类的ViewRootHandler
。这个类中定义了一系列View需要用到的消息并进行了处理,如INVALIDATE
等。
-
直接new
-
调用
Message.obtain()
或者Handler#obtain()
第二种方法好,因为使用了消息池复用。因为Message类本身就可以作为一个链表的节点,所以消息池的数据结构是一个链表,每次复用取出头节点。
5. Handler是怎样起到切换线程作用的?是怎样在子线程发送消息然后在主线程处理的?
Handler发送消息的过程仅仅只是把消息放进消息队列里,这是在子线程里完成的。
主线程的Looper是一直在主线程运行的,当发现有新消息之后,就会提取出来,然后再在主线程把消息传递给Handler进行处理;这样就完成了线程切换。
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以添加V获取:vip204888 (备注Android)
最后
这里附上上述的技术体系图相关的几十套腾讯、头条、阿里、美团等公司2021年的面试题,把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节,由于篇幅有限,这里以图片的形式给大家展示一部分。
相信它会给大家带来很多收获:
当程序员容易,当一个优秀的程序员是需要不断学习的,从初级程序员到高级程序员,从初级架构师到资深架构师,或者走向管理,从技术经理到技术总监,每个阶段都需要掌握不同的能力。早早确定自己的职业方向,才能在工作和能力提升中甩开同龄人。
- 无论你现在水平怎么样一定要 持续学习 没有鸡汤,别人看起来的毫不费力,其实费了很大力,这四个字就是我的建议!!!
- 我希望每一个努力生活的IT工程师,都会得到自己想要的,因为我们很辛苦,我们应得的。
当我们在抱怨环境,抱怨怀才不遇的时候,没有别的原因,一定是你做的还不够好!
技术体系图相关的几十套腾讯、头条、阿里、美团等公司2021年的面试题,把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节,由于篇幅有限,这里以图片的形式给大家展示一部分。
相信它会给大家带来很多收获:
[外链图片转存中…(img-qfOHTLKK-1711967666717)]
当程序员容易,当一个优秀的程序员是需要不断学习的,从初级程序员到高级程序员,从初级架构师到资深架构师,或者走向管理,从技术经理到技术总监,每个阶段都需要掌握不同的能力。早早确定自己的职业方向,才能在工作和能力提升中甩开同龄人。
- 无论你现在水平怎么样一定要 持续学习 没有鸡汤,别人看起来的毫不费力,其实费了很大力,这四个字就是我的建议!!!
- 我希望每一个努力生活的IT工程师,都会得到自己想要的,因为我们很辛苦,我们应得的。
当我们在抱怨环境,抱怨怀才不遇的时候,没有别的原因,一定是你做的还不够好!