0.前言
Handler作为Android代码编写以及面试时经常遇到的内容，有必要花个时间整理一下，毕竟写过的东西印象会更加深刻。
1.什么是Handler?
1.1 定义
源码里面捞出来的内容，英文不难看懂。主要就是说每个Handler会和每个线程以及线程对应的消息队列相绑定。之后消息就可通过Handler在线程之间传递。
A Handler allows you to send and process {@link Message} and Runnable objects associated with a thread's {@link MessageQueue}. Each Handler
instance is associated with a single thread and that thread's message queue. When you create a new Handler, it is bound to the thread ，message queue of the thread that is creating it -- from that point on,
it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.
<p>There are two main uses for a Handler:
(1) to schedule messages and runnables to be executed at some point in the future; and
(2) to enqueue an action to be performed on a different thread than your own.
1.2 Handler的作用
Handler 的作用主要为两个：
- 让程序在未来的某个时间点去执行一些事情
- 事件跨线程传递执行（最主要的使用就是子线程让主线程去做一些刷新的事情）
1.3 Handler的基本用法
1.在未来某个时刻去执行runnable中的事件
handler.post(runnable,delayMillis);
2.不同消息间传递事件
android.os.Handler handler = new Handler(){
@Override
public void handleMessage(final Message msg) {
//这里接受并处理消息
}
};
//发送消息
handler.sendMessage(message);
2.Handler基本原理
2.1 Handler原理相关的类
- Handler
- Looper
- MessageQueue
- Messagre
2.2 Handler原理概述
首先放一张Handler消息处理的原理图
根据图一步步梳理Handler实现机制
2.3 Handler工作流程
2.3.1 创建Handler
首先第一步是创建Handler,Handler的构造函数主要有如下几个
其中的参数如下
-
boolean async
async 该参数确定用Handler发送的消息是否要设置成异步消息，如果为ture设置为异步消息，异步消息可和同步阻塞一起配合使用，典型的例子是界面的定时刷新。
-
Callback callback
设置了该参数，那么Handler在dispatchMessage回调时会优先调用callback中的代码，若返回为true,则不再执行handleMessage的回调
/**
* Handle system messages here.
*/
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
-
Looper looper
设置该Hanlder对应的Looper参数，对于每个Handler,都有一个对应的Looper,每个Looper有其对应的MessageQueue。如果没有显式的设置Handler的Looper,那么Handler默认会取该线程对应的Looper赋给该Handler。
2.3.2 Handler发送消息
Handler发送消息主要调用的是sendMessage方法。
sendMessage(@NonNull Message msg)
发送消息的方法有许多不同的名称和参数。但是，你从源码一步步看最后都会指向如下的这段代码
public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
看这段代码我们会发现，其主要的操作就是调用压队列的方法。传入的参数是队列，消息以及对应的事件
2.3.3 MessageQueue压入消息
该方法首先是对Message 实例进行各种参数的设置，最主要的就是target参数，该参数用于确定消息从MessageQueue中取出后去调用哪个Handler的dispatchMessage，从而进行消息的处理。
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);
}
设置完参数，Handler的enqueueMessage就会去调用MessageQueue的enqueueMessage方法，代码如下
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle();
return false;
}
msg.markInUse();
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中的when参数从列表中来找到需要插入的点，并把Message进行参入。
2.3.4 Looper取出消息
Looper取出消息主要是调用了Looper类的loop方法，该方法里面有一个for(;;）循环，不停的从MessageQueue中取出消息。
for (;;)
{
Message msg = queue.next();
……
}
2.3.5 Handler处理消息
当消息取出以后，即会调用
msg.target.dispatchMessage(msg);
来处理消息，这个target即时开始enqueMessage时塞入的Handler。
从Handler中我们可以看到，这dispatchMessage(Message msg)方法。
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
其中handleMessage(msg)就是我们自定义Handler时的回调，这样消息就走完了整个流程。
3.Handler延伸
3.1 Q Handler 为什么会导致内存泄漏，该如何处理这个内存泄漏问题？
A: Handler的普通用法如下：
Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
}
};
由于Handler是通过匿名内部类的方式实现的，所以其会对外部类有引用（通常为Activity），这就会引起内存泄漏。
通常的解决如下
把Handler定义成静态内部类，如Handler中需要对外部类的参数有引用，那么可以使用弱引用，示例代码如下
private static class MyHandler extends Handler{
//持有弱引用HandlerActivity,GC回收时会被回收掉.
private final WeakReference<HandlerActivity> mActivty;
public MyHandler(HandlerActivity activity){
mActivty =new WeakReference<HandlerActivity>(activity);
}
@Override
public void handleMessage(Message msg) {
HandlerActivity activity=mActivty.get();
super.handleMessage(msg);
if(activity!=null){
//执行业务逻辑
}
}
}
3.2 Q Handler类中有个Callback的接口，请问这个接口有什么用？
A: 这个的设计主要是为了解决Handler内存泄漏的问题。
可参考如下代码：
Handler handler = new Handler(new Handler.Callback(
@Override
public boolean handleMessage(Message msg) {
if (msg.what ==1){
textView.setText("Hello!");
return true;
}
return false;
));
该接口的调用主要出现在dispatchMessage中，从此处的代码可知道，如果mCallback变量没有定义，变量为空，会走Handler系统的方法hadlerMessage（Message msg）,而如果mCallback变量定义了，那么其会运行到mCallback
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
3.3 Q Handler中的普通消息，异步消息和消息屏障是什么关系？有什么作用？
MessageQueue中的Message一共有三种类型，即普通消息，异步消息和消息屏障。区别是消息屏障它的target为null。而普通消息和异步消息是通过setAsynchronous为true来进行区分的。
在设置消息屏障后，异步消息具有优先处理的权利。界面的定时刷新就是用的这个机制
3.4 Q Message的target是什么时候注入的？
捞取Handler的源码发现如下这段
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);
}
即哪个Handler把Message存入的消息队列，最后回调的就是这个Handler对应的dispatchMessage 方法。
3.5 Q Looper会不停的从消息队列中取消息吗？
不会，若MessageQueue中消息已经取完或者消息要在之后的某个事件才会促发，则会调用native方法 nativePollOnce(long ptr, int timeoutMillis)，使主线程处于等待状态。当调用了往消息队列塞入消息时，则会调用nativeWake(long ptr)方法唤醒主线程，所以尽管，loop方法中有个for死循环，但是这不会导致Looper不停从消息队列取数据。
3.6 Q Handler的post(Runnable r) 方法是如何实现Runnable中事件的执行的？
post方法从本质上来说也是用的Message消息传递的流程。
public final boolean post(@NonNull Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
从如下两端代码可看出其是对runnable进行了封装，把runnable塞进了Message中。而当Handler获得消息后，其会取出msg.callback参数，然后运行里面的runnable方法。
3.7 Q 平时代码编写中如何获得Message对象比较好？
用Message.obtain()获取比较好，避免了gc导致的性能消耗。
3.8 Q IdleHandler是什么，有什么作用？
IdleHandler是在主线程消息队列空闲时，会被取出执行的对象。可在一些页面优化的情景下使用。
