面试中 - Handler引发的那些灵魂拷问

最新推荐文章于 2022-11-25 10:01:43 发布

邪恶的鱼蛋

最新推荐文章于 2022-11-25 10:01:43 发布

阅读量2.8k

点赞数 1

分类专栏： android 文章标签： android 面试

本文链接：https://blog.csdn.net/yudan505/article/details/113716381

版权

android 专栏收录该内容

9 篇文章 2 订阅

订阅专栏

如果还有遇到别的问题的同学评论区打上，我会补上的。也欢迎纠错！
更新记录：20210314，增加内容：1.4、1.5、1.6、1.7

如果对Handler源码不够了解可以看看这个：Handler源码学习记录（java层、native层）

模仿Handler原理，使用eventfd+epoll实现Handler基础功能的小案例 -> gayhub地址(MessageQueueDemo)

文章目录

1 Handler是什么？

android提供的线程切换工具类。主要的作用是通过handler实现从子线程切换回主线程进行ui刷新操作。

1.1 为什么Handler能实现线程切换？

在创建Handler的时候需要传入目标线程的Looper。(没有传入Looper默认拿当前线程的Looper，如果当前线程也没有准备好Looper会抛异常)
而当sendMessage的时候，会将当前的Handler对象赋值给Message中的target变量。并将该Message存到传入目标线程Looper的MessageQueue中
当Looper消费Message的时候便会拿到Message中的taeget执行dispatchMessage(msg)方法，从而实现线程切换。

1.2 为什么主线程才能刷新ui，子线程不可以？

‘android的ui刷新并不是线程安全的’ 所以必须要有一个线程专门来做这件事情，那就是主线程。
刷新ui的时候会检查当前线程是否为主线程，如果不是会抛异常。

view在更新的时候由于可能会发生大小、位置等变化，会执行requestLayout来告诉父View自己要更新layout。
然后父View也会一层层调用requestLayout，最终去到ViewRootImpl#requestLayout，在其requestLayout中
会进行线程检查。

//ViewRootImpl#requestLayout
@Override
public void requestLayout() {
        if (!mHandlingLayoutInLayoutRequest) {
            checkThread();
            mLayoutRequested = true;
            scheduleTraversals();
        }
    }

//ViewRootImpl#checkThread
void checkThread() {
    if (mThread != Thread.currentThread()) {
        throw new CalledFromWrongThreadException(
                "Only the original thread that created a view hierarchy can touch its views.");
    }
}

严格来说，子线程也不是不可以刷新ui。详细的文章：https://blog.csdn.net/xyh269/article/details/52728861

1.3 为什么android要设计成只有在主线程才能刷新ui？

设计成单线程刷新，目的是提高稳定性以及提高性能。
①提高稳定性：由于多线程存在资源共享的问题一旦处理不妥当，会造成数据丢失、重复以及错乱等问题。单线程能有效降低出错风险，提高稳定性。
②从①中引申出，如果要处理好多线程的资源共享的问题，就需要增加同步锁、原子类、线程安全的集合等。这样必然会存在等待，而且由于ui刷新是非常
频繁的，如果出现大量而又频繁的等待，会增加cpu的负担，从而导致性能下降。

以上是个人观点，可以看看大佬更加全面的文章：https://blog.csdn.net/qq_39154578/article/details/83782287

1.4 你听过异步消息么？它实现原理是什么？（from 微信）

听说过它是handler消息的一种。handler有三种消息同步消息、异步消息、屏障消息。
异步消息享有优先权的消息，它其实与同步消息没什么差别，唯一区别是异步消息把Message setAsynchronous(true)而已。真正让异步消息享有优先权的是屏障消息。
首先消息队列是一个链表结构，当屏障消息入队之后，屏障消息后边的所有消息都受到管控，只有异步消息能通过。直到屏障消息被移除同步消息才能继续通过。
消息队列在取消息的时候，会先判断当前消息是否为屏障消息，如果是那么会一直往后查，直到找到异步消息。如果这个异步消息还没到执行时间，那么会继续休眠。

1.5 Handler如何处理发送延迟消息？（from 腾讯）

延时机制是通过native层用eventfd+epoll实现的。
handler在发送延时消息的时候，延时消息入队，消息队列只对其按照消息执行时间插入到链表里边。
而在Looper.loop中有一个死循环会一直轮询，一直从消息队列取消息，如果取不到消息会进行等待。如果需要出队的消息未到执行时间，会计算等待时长并调用native方法让epoll进入等待并且会设置等待时长。直到epoll等待超时便会返回，java层Looper.loop就会拿到该延时消息了。
其实延时消息的实现并没有用到eventfd，eventfd的作用是用来打断epoll的等待。例如当处理有新的非延时消息入队时能够打断epoll的等待，从而让java层获取这个非延时消息。

1.6 Handler的post(Runnable)如何实现的；callback，runnable，msg的执行优先级。（from 字节）

runnable是存放在Message里边的，变量为callback。
post(Runnable)是在内部先通过Message.obtain()拿到一个空的Message，并将Runnable赋值给该Message的callback变量，并且Message target变量会持有当前Handler对象。当消息队列轮询到该Message的时候会调用其target变量，执行dispatchMessage方法。dispatchMessage方法内部会检查并调用callback变量，从而实现Handler的post(Runnable)。

执行优先级是：
msg.callback
Handler mCallback
Handler handleMessage

//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#handleCallback
private static void handleCallback(Message message) {
        message.callback.run();
    }

1.7 HandlerThread的原理是什么？（from 顺丰）

HandlerThread其实就是运行在子线程的Handler。作用是为了让使用者从其他线程切换到该子线程。
其内部是创建了自己的Looper、Handler，并且在run方法里边启动了这个Looper，让其一直轮询。并且以这个Looper创建了一个Handler，并且暴露给外部使用。
当不需要使用这个HandlerThread时，需要调用quit退出。不然该HandlerThread将无法停止，可能会导致内存泄漏。

2 一个线程有几个Handler?

可以创建无数个，但是其内部的Looper只会有一个。

2.1 一个线程有几个Looper？如何保证？

一个线程只有一个Looper；
Looper内部是通过ThreadLocal保证的线程唯一，在Looper.prepare方法的时候创建并set进ThreadLocal。

2.2 为什么ThreadLocal能保证Looper线程唯一？

因为线程维护了一个ThreadLocalMap的容器，该容器专门提供给ThreadLocal获取数据。
key就是ThreadLocal，value就是需要获取的数据。

ThreadLocal设计思想
① Thread 内部持有一个全局变量ThreadLocalMap<ThreadLocal（弱引用）, T （强引用）> threadLocals
② ThreadLocal内部
get() -> 获取当前thread对象 -> 获取threadLocals（并且判空，为空就为该thread创建threadLocals）-> map.get(this) 获取到value
set(T value) -> 获取当前thread对象 -> 获取threadLocals（并且判空，为空就为该thread创建threadLocals）-> map.set(this, value)
remove() -> 获取当前thread对象 -> 获取threadLocals -> map.remove(this)

3 为什么主线程可以new Handler?

主线程：
ActivityThread main方法已经帮我们准备好Looper了。
Looper.prepareMainLooper()
Looper.loop() 这个是死循环，是主线程一直存活的关键。
所以在主线程可以直接new Handler，而且还可以不用穿Looper参数。(没有传入Looper默认拿当前线程的Looper，如果当前线程也没有准备好Looper会抛异常)

3.1 那么子线程中如何使用Handler?

Looper.prepare() 准备Looper
Looper.loop() 让Looper运行起来
Looper.myLooper() 提供给Handler获得该线程的Looper
由于子线程的Looper创建是在prepare()中，无法保证外部的Hander立即能获得有效的Looper，所以需要做同步锁操作。

HandlerThread 封装好了一切同步操作，也可以用它。

3.2 子线程维持的Looper，无消息应该怎么处理？

由于Looper.loop()的存在会一直阻塞线程，线程是不会退出的，可能会导致内存泄漏。
需要手动退出 Looper.quit() -> MessageQueue quit()
MessageQueue quit()工作：清空所有Message，nativeWake唤醒等待，next()继续执行，dispose()

3.3 为什么主线程的Looper不需要退出？

如果主线程Looper退出了，整个程序就会退出了。因为整个app程序都是依靠Looper来分发处理消息，处理生命周期回调的。

4 Handler内存泄漏的原因是什么？

匿名内部类默认会持有外部类的引用。
内存泄漏：程序在向系统申请分配内存空间后(new)，在使用完毕后未释放。内存泄漏容易造成OOM(内存溢出)。
OOM：我想要使用一个4M的连续空间，但是找不到。系统就会抛出OOM。

MessageQueue维护着所有将要处理的Message，在enqueueMessage的时候，将Handler对象存入Message target变量中。
所有Message的生命有可能会比Handler所在的Activity生命要长，Activity销毁了，但是Message都还没执行的话，该Activity
就无法销毁，导致内存泄漏。

5 Handler的消息阻塞是怎么实现的？

Handler的实现原理是使用了linux的两个系统调用实现的：eventfd + epoll
eventfd 负责通知
epoll 负责监听
首先会通过eventfd系统调用创建一个唤醒fd并且注册到epoll里边。
如果当有延时消息入队的时候，会根据消息的延时时长为epoll设置阻塞时长，知道超时epoll自动唤醒，然后返回java层处理消息
如果当有立即执行的消息入队的时候，会通过写入数据到唤醒fd从而唤醒epoll，然后返回java层处理消息
如果没有消息，epoll会一直阻塞，直到被唤醒。

5.1 Looper.loop()会阻塞主线程但为什么不会出现ANR？

ANR：应用无响应异常
ANR产生原因：当前的事件没有机会得到处理
例如：当前在处理一个点击事件，但是这个点击事件里边的处理是耗时的，主线程就会等待这个耗时的处理。
与此同时另外一个点击事件发送过来了，新的事件就会被阻塞。当事件超过某一个时间限制(触摸事件一般是5s)
仍未被执行，就会抛ANR。

所以ANR与Looper.loop()的阻塞是不相关的。并且Looper.loop()的阻塞是为了保证主线程不退出而设计的。

更详细的文章：https://blog.csdn.net/qq_32583189/article/details/52253147

6 Handler如果让Message尽快执行执行？

发送异步消息。
方法：使用Message#setAsynchronous设置

这样还是不能实现尽快执行的，还需要增加同步屏障（一种特殊的消息）
但是添加以及移除同步屏障的方法，对开发者是不公开的。所以需要使用反射去设置。
记住：使用完之后必须要移除同步屏障，不然同步屏障后面的所有同步消息都无法执行的。
同步屏障的作用：拦截同步屏障后面所有同步消息，只允许异步消息用过。

使用场景介绍：ViewRoomtImpl中为了让消息尽快执行大量使用了异步消息

//ViewRoomtImpl#scheduleTraversals
void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier(); //添加消息屏障
            ...
        }
    }

//ViewRoomtImpl#unscheduleTraversals
    void unscheduleTraversals() {
        if (mTraversalScheduled) {
            mTraversalScheduled = false;
            mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier); //移除消息屏障
            ...
        }
    }

7 Handler有没有一些机制是有助于程序优化的？

IdleHandler：可以在程序空闲的时候，做一些不太耗时的操作。
使用方法：
mHandler.getLooper().getQueue().addIdleHandler
mHandler.getLooper().getQueue().removeIdleHandler

IdleHandler#queueIdle()：
返回值用于告诉MessageQueue
true：每次进入阻塞都会调用该IdleHandler，直到该IdleHandler被移除。
false：只调用一次IdleHandler，就被自动移除了。

使用场景：
1、Activity启动优化，onCreate，onStart，onResume中耗时较短但非必要的代码可以放到IdleHandler中执行，减少启动时间。
2、想要一个View绘制完成之后添加其他依赖于这个View的View，当然这个View#post()也能实现，区别就是前者会在消息队列空闲时执行。

详细的文章：https://www.jianshu.com/p/1dc73c8ab6a1

8 MessageQueue如何保证线程安全？

MessageQueue内部的很多方法为了保证线程安全，都增加了对象锁synchronized (this)。

9 Message怎么创建？

Message.obtain()：使用复用池，减少new Message，防止频繁GC。（频繁GC会导致内存抖动（STW） -> 导致卡顿）
设计模式：享元模式（类似例子 recycleview bindView createView）

邪恶的鱼蛋

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
2
评论
面试中 - Handler引发的那些灵魂拷问

努力完善中。。。o(╥﹏╥)o 如果还有遇到别的问题的同学评论区打上，我会补上的。也欢迎纠错！1 Handler是什么？android提供的线程切换工具类。主要的作用是通过handler实现从子线程切换回主线程进行ui刷新操作。1.1 为什么Handler能实现线程切换？在创建Handler的时候需要传入目标线程的Looper。(没有传入Looper默认拿当前线程的Looper，如果当前线程也没有准备好Looper会抛异常)而当sendMessage的时候，会将当前的Handler对象赋值给
复制链接

扫一扫

专栏目录