Handler面试题
-
一个线程有几个Handler?
一个线程比如主线程,我们可以在主线程中创建多个Handler;所以一个线程中是可以包含任意多个Handler的. -
线程间通信的原理是怎么样的?
通常情况下我们会在子线程中,通过调用handler.sendMessage()方法发送消息;然后在主线程中Handler的回调方法handleMessage()中去处理消息;从而实现子线程与主线程通信.
分析线程间通信的流程:子线程:通过Handler发送消息Message到MessageQueue消息队列中
handler.sendMessage()- ->sendMessageDelayed
- ->sendMessageAtTime()
- ->enqueueMessage
- ->(MessageQueue)
queue.enqueueMessage- 将发送的消息添加到消息队列MessageQueue中,这里会去遍历之前的消息Message,并把心来的消息插进去.消息的实现方式是单链表,每个消息对象中会包含一个next变量存储下一个消息,消息之间是按照执行时间排序的,最早执行的消息排在最前面.
主线程:通过Looper从MessageQueue中取出消息并处理
ActivityThread.main()- 这个main()方法中会调用
Looper.prepareMainLooper()方法,创建sMainLooper对象;然后调用调用Looper.loop()方法开启死循环,从消息队列中取消息分发给Hanlder处理.
- 这个main()方法中会调用
Looper.loop()- 通过(Looper)me.mQueue获取到消息队列
- ->(MessageQueue)
queue.next()- 通过一个死循环不停地从消息队列中取消息
- ->msg.target.dispatchMessage(msg)
- 注意:msg.target是Message中的target变量,是Handler对象的变量,所以这里其实是调用的Handler中的dispatchMessage()方法
- ->(Handler)
dispatchMessage()- 调用Hanler中的分发消息方法dispatchMessage()
- ->
handleMessage(msg)- 最终回调我们Activity/Fragment中创建的Handler中的handleMessage方法,我们在这里处理消息.
总结: (
线程间通信的原理就是内存共享)
由于线程间内存共享的机制,使得共享的Message消息对象可以通过子线程添加到MessageQueue消息队列中,接着主线程可以取出共享的MessageQueue队列中的Message对象进行处理.
举例:
Activity中创建的成员变量,我们在主线程和子线程中都可以去访问和修改这个成员变量,这就是线程间内存共享的案例. -
Handler内存泄漏的原因?为什么其他内部类没有这个问题?
- 解决方案:
- 首先我们可以通过将
Handler声明称静态的static,因为静态内部类不会持有外部类的引用,从而页面可以正常销毁. - 在页面销毁的时候,调用
removeCallbacksAndMessages(null)方法,这个方法会回收Hanlder持有的消息队列MessageQueue中的所有消息Message;该方法会遍历消息单链表,依次调用每一个消息的Message.recycleUnchecked()方法进行消息回收.从而避免延迟消息也页面销毁时未执行导致内存泄漏.
- 首先我们可以通过将
- 问题分析:
MainActivity- 创建内部类Handler,并重写handleMessage()方法
Handler mHandler = new Handler() { @Override public void handleMessage(@NonNull Message msg) { super.handleMessage(msg); } };
- 创建内部类Handler,并重写handleMessage()方法
<-Handler- 非静态内部类Handler会持有外部类MainActivity的引用
<-Message- 发送的消息Message会持有Handler类.在发送消的过程中,Handler中的enqueueMessage()方法里会有如下一段代码:
msg.target = this;
Message就会持有this,这个this就是Handler类.
- 发送的消息Message会持有Handler类.在发送消的过程中,Handler中的enqueueMessage()方法里会有如下一段代码:
<-MessageQueue- 消息会添加到消息队列MessageQueue中,将消息添加到消息队列中的mMessages单链表中
<-LooperLooper会调用prepareMainLooper()方法中的prepare()方法,将创建的Looper对象设置到ThreadLocal中去,代码如下:
sThreadLocal.set(new Looper(quitAllowed));
同时会执行如下代码,将ThreadLocal中存储的Looper对象赋值给一个静态变量sMainLooper,该变量的声明如下:
private static Looper sMainLooper;
这里sMainLooper是一个静态变量,他是GC Root对象,会持有所在类Looper,从而导致了内存泄漏.
在使用Looper的loop()方法时,会调用MessageQueue的next()方法,从消息队列中取出消息进行进行处理,从而因为(Looper)sMainLooper是一个静态变量,是GC Root对象,无法被JVM回收,存在导致内存泄漏的风险.- 当
Looper调用loop()方法,通过一个死循环从消息队列中取出消息分发给Hanlder去处理时,当消息被处理掉则不会导致内存泄漏.
总结:
由于页面在销毁的过程中,Looper类中的sMainLooper是静态变量,而静态变量是GC Root对象,无法被JVM回收,所以导致了Looper无法被回收,从而导致向上引用的MessageQueue、Message、Handler和MainActivity都无法被回收,从而导致了内存泄漏.
当我们将MainActivity中的Handler声明成static,内部类Handler就不会持有外部类MainActivity的应用,从而MainActivity销毁时可以被JVM正常回收;
当我们在MainActivity销毁的时候调用removeCallbacksAndMessages(null)方法,可以回收所有的消息Message对象,从而Message就不会持有Handler的引用,从而Message、Handler和Activity都可以正常被回收. - 解决方案:
-
为什么主线程可以new Handler?如果要在子线程中new Handler要做什么准备?
- 主线程之所以能创建Handler:
是因为Activity在启动的时候,会执行ActivityThread中的main()方法,这个方法中会执行这两行代码Looper.prepareMainLooper()和Loop.loop(),他们的作用分别是创建Looper对象,这个Looper对象是创建在主线程中的;创建一个死循环不停的从消息队列中取消息分发给Handler处理.
因此我们可以直接在主线程中创建Handler,然后发送消息和处理消息. - 子线程中如何创建Handler:
模拟主线程中创建Looper对象和执行loop死循环轮询消息,在子线程中调用Looper.prepare()和Looper.loop()方法,然后在这两行代码中间创建Handler,即可实现在子线程中创建Handler. - 优化方案:
- 利用系统提供的
HandlerThread创建子线程,这个线程在启动后,获取到CPU时间片会执行run()方法,然后会调用Looper.preapare()和Looper.loop(),在这两行代码中间添加synchronize和notifyAll功能,从而在执行完成synchronize代码块中代码后,会通知我们getLooper()方法中使用wait()函数的代码块,执行wait()方法后面的业务逻辑,从而使得获取到的looper对象非空.
代码如下:synchronized (this) { mLooper = Looper.myLooper(); //获取到Looper.prepare()创建的Looper对象后, //通知所有使用wait()方法代码块,执行wait()方法后面代码逻辑 notifyAll(); } //我们在调用这个方法获取looper对象时,里面的wait方法会释放当前锁资源, //并处于等待状态,当我们的子线程在执行run方法时,当获取到的looper对象非空, //会调用notifyAll方法通知等待的wait方法执行后面的业务, //从而保证了getLooper()返回的mLooper对象非空 public Looper getLooper() { // If the thread has been started, wait until the looper has been created. synchronized (this) { while (isAlive() && mLooper == null) { try { //一直处理等待状态,等待notifyAll方法被调用,然后执行wait方法后面的业务逻辑, //从而保证了后面返回的mLooper对象非空 wait(); } catch (InterruptedException e) { } } } return mLooper; } HandlerThread使用案例://创建HandlerThread子线程 HandlerThread mHandlerThread = new HandlerThread("mHandlerThread"); //启动线程 mHandlerThread.start(); //然后将子线程中创建的Looper对象，作为创建Handler的参数 Handler mThreadHandler = new Handler(mHandlerThread.getLooper(), new Handler.Callback() { @Override public boolean handleMessage(@NonNull Message msg) { if (msg.what == 1000) { Toast.makeText(TKActivity.this, "处理子线程中创建的Handler发送过来的消息", Toast.LENGTH_SHORT).show(); } return false; } }); //利用子线程中创建的Handler发送消息 mThreadHandler.sendEmptyMessage(1000);
- 利用系统提供的
- 主线程之所以能创建Handler:
-
子线程中维护的Looper,消息队列中无消息的时候处理方案是什么?有什么用?
-
即然可以存在多个Handler往MessageQueue中添加数据(发消息时各个Handler可能处在不同的线程中),那么内部是如何保证线程安全的?
多个线程同时在往消息队列MessageQueue中添加消息enqueueMessage()的时候,都会对代码块进行加锁synchronized处理,从而保证了多线程添加消息安全性;在调用和next()取消息的时候,同样对代码块进行了加锁synchronized处理,这样处理的目的是为了保证添加消息和取消息的互斥性,保证了添加消息和取消息不能同时进行;
从而保证了多个线程在同时发送消息和取消息时的线程安全问题. -
我们使用Message时应该如何创建它?
为什么要用Message.obtain()创建Message对象呢?
Looper在调用loop()方法不停轮询消息时,从消息队列中取出消息在处理完后,会将这个消息中的数据清空msg.recycleUnchecked(),然后将这个消息添加到消息缓存池单链表中第1位;在我们要发送消息的时候,采用Message.obtain()方法从消息缓存池sPool中取出第1个消息使用,从而避免了内存浪费.
扩展:
消息缓存池最大值是50
private static final int MAX_POOL_SIZE = 50;//通过Message.obtain()方式创建Message Message message = Message.obtain(); message.what = 1000; message.obj = "tangkun"; handler.sendMessage(message); //查看obtain方法创建message的源码 private static Message sPool; public static Message obtain() { //通过内置锁保证获取到消息过程线程安全 synchronized (sPoolSync) { if (sPool != null) { //取出消息缓存池sPool单链表中第一个结点 Message m = sPool; //将消息缓存池第一个结点指向的下一个结点作为新的消息缓存池 sPool = m.next; //清除消息缓存池单链表中第一个结点指向下一个结点的指针 m.next = null; //清空使用中标记 m.flags = 0; // clear in-use flag //消息缓存池大小减去1 sPoolSize--; //返回消息缓存池中第一个结点 return m; } } //消息缓存池中没有消息会创建一个新的消息 return new Message(); } -
Looper死循环为什么不会导致应用卡死?
当消息队列MessageQueue中没有消息的时候,我们调用Looper.loop()方法轮询消息时,从消息队列MessageQueue中调用next()方法取消息时,就会进入到休眠状态,休眠代码如下:
nativePollOnce(ptr, nextPollTimeoutMillis);
而ANR在触发的过程中与我们的Looper机制没有任何关系,所以我们的Looper从消息队列中取消息过程中,消息队列中没有消息时,从消息队列中取消息的过程就会进入到休眠状态.
ThreadLocal原理分析
Looper在调用prepare()方法创建Looper对象的过程中,就会将创建的Looper对象设置到ThreadLocal中去,代码如下:
sThreadLocal.set(new Looper(quitAllowed));
当我们在调用Looper.myLooper()方法获取Looper对象时,会调用sThreadLocal.get()方法,就可以获取到当前线程的Looper对象.
每一个子线程Thread中都包含一个ThreadLocalMap变量,用来存放在当前线程中创建的Looper对象,同时可以根据当前线程获取到存入的Looper对象.
//每一个子线程中都包含了一个ThreadLocalMap变量,
//这个ThreadLocalMap中存放着当前线程对应的Looper对象
//也就是说每个线程中存放着一个当前线程的Looper对象
class Thread implements Runnable {
//每个子线程中都包含了一个ThreadLocalMap变量
ThreadLocal.ThreadLocalMap threadLocals = null;
}
class ThreadLocal{
//返回当前线程中ThreadLocalMap中存放的Looper对象
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
//将Looper对象存入ThreadLocalMap中,key是当前ThreadLocal对象,value是创建Looer对象
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
//ThreadLocal的内部类ThreadLocalMap
static class ThreadLocalMap {
//内部Entry对象,以ThreadLocal作为key,Looper作为value
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
}
}
epoll阻塞机制
epool是Linux内核中一种可扩展IO事件处理机制.
我们从消息队列中取消息的时候,当没有消息队列中没有消息时,就会调用如下jni代码,进入阻塞状态:
nativePollOnce(ptr, nextPollTimeoutMillis);
当有新的消息添加到消息队列中时,就会调用如下jni代码,唤醒Looper重新到消息队列中去取出消息处理:
nativeWake(mPtr);
消息Message
- 同步消息
- 我们平时通过Handler发送的消息就是同步消息
- 异步消息
- 在ViewRootImpl中的scheduleTraversals()方法中,发送完屏障消息后,会发送异步消息,用于刷新屏幕,代码如下:
mChoreographer.postCallback(Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
这条消息会被标记成异步消息,代码如下:
msg.setAsynchronous(true);
- 在ViewRootImpl中的scheduleTraversals()方法中,发送完屏障消息后,会发送异步消息,用于刷新屏幕,代码如下:
- 屏障消息
- 在ViewRootImpl中的scheduleTraversals()方法中,会发送屏障消息,
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
在发送屏障消息postSyncBarrier()方法中,会从消息缓存池中取出第1个消息并给他赋值作为屏障消息,然后根据执行时间将这条屏障消息插入到同步消息单链表中去.
屏障消息和同步消息的区别:- 屏障消息
Message中的target为null;因为是从消息缓存池中取出的消息,但是没有给target赋值,所以target为null. - 同步消息在Handler发送消息的过程中,调用enqueueMessage方法时,会将当前的Hanlder赋值给消息的target变量,代码如下:
msg.target = this;//这里的this就是当前Handler类
- 屏障消息
- 在ViewRootImpl中的scheduleTraversals()方法中,会发送屏障消息,
总结:
异步消息通过调用msg.setAsynchronous(true)
屏障消息的msg.target=null
同步消息的msg.target=(Handler)this
注意:在View绘制流程中,也就是ViewRootImpl的scheduleTraversals()方法中,会先发送屏障消息,然后发送异步消息,这两条消息获取的时间是当前时间戳,所以在添加到消息队列中,屏障消息先添加,会插入到消息队列的头部;而异步消息后添加,会添加到屏障消息后面;但是这两条消息都优先于我们的Activity中创建的Handler,发送的同步消息之前执行,因为他们排在消息队列的前面.
IdleHandler分析
在Handler发送的所有消息(延迟时间为0)都执行完成后,主线程空闲下来的时候,才会去执行IdleHandler中的业务逻辑,从而达到减少我们进入页面一瞬间执行任务的时间的目的.
使用案例:
//创建一个IdleHandler，当我们的线程空闲下来，才会去执行的里面的业务逻辑
Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
@Override
public boolean queueIdle() {
Log.e(TAG, "虽然IdleHandler的代码逻辑写在了最前面，但是他会等我们的主线程空闲下来，才会执行回调方法中的业务逻辑");
return false;
}
});
注意:
Handler发送的延时消息仍然会在IdleHandler之后执行,只有延时为0的消息才会在IdleHandler之前执行.
466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
