一个线程至多有一个looper；一个looper有一个MessageQueue；一个MessageQueue对应多个message；一个MessageQueue对应多个Handler。消息类型有同步（Message），异步（Async Message），同步屏障（BarrierMessage）消息。消息分发的优先级
1.Message的回调方法：message.callback.run()，优先级最高
2.Handler的回调方法 Handler.mCallBack.handleMessage(msg)
3.Handler的默认方法：Handler.handleMessage(msg)
上图是Android消息机制的图解
图中分为四个部分，Handler, Looper, MessageQueue, Message Hander主要是将消息发送到MessageQueue中，和处理接收到消息后执行的代码。
Looper主要是不断的循环遍历MessageQueue中的Message，从而找到合适的Message进行处理
MessageQueue是一个单向链表结构，用来存储消息
Message是消息实体
启动Looper
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler(Looper.myLooper()) {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
Looper.loop();
}
}
需要使用Handler，首先要启动Looper。而主线程中，ActivityThread中已经帮我们启动了Looper，所以我们可以直接使用Handler。 启动Looper需要调用Looper的两个方法
Looper.prepare();
Looper.prepare();创建了Looper的实例，并将Looper的实例放入ThreadLocal中。这样你在Looper myLooper()中就能获取 当前线程的Looper
Looper.prepare()
Looper.loop();开始遍历MessageQueue
消息的发送与插入
Message中主要的字段有
Long when标志这个消息将在什么时候被触发，MessageQueue中消息的排序也是依赖when
Handler target标志这个消息由哪个Handler发送，会由哪个Handler来处理。target = null时该消息为同步屏障消息
Runable callback所有通过Handler.post发送的Runable对象都将被绑定到这个字段上。
Message next指向下一个MessageQueue中的下一个Message
Object objMessage中存储数据的变量
handler主要负责添加消息的MessageQueue中。 Handler发送消息的方法有
public final boolean sendEmptyMessage(int what)
public final boolean sendMessage(@NonNull Message msg)
public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis)
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis)
public final boolean sendEmptyMessageDelayed(int what, long delayMillis)
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis)
public final boolean postDelayed(@NonNull Runnable r, @Nullable Object token, long delayMillis)
public final boolean post(@NonNull Runnable r)
public final boolean postAtTime(@NonNull Runnable r, long uptimeMillis)
其中sendMessageAtTime和postAtTime需要注意，他们接受的参数long uptimeMillis是绝对时间，比如说你想让传入的消息或回调延迟300ms触发，则时间参数需要这样写SystemClock#uptimeMillis + 300因为Handler所有的时间都是以SystemClock#uptimeMillis为基础来计算的，该方法是记录从开机运行到现在的时间戳，设备在深度睡眠的情况下该时间戳不累加
handler中所有send开头和post开头的方法最终都会调用 private boolean 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);
}
在enqueueMessage方法中首先将msg中的target赋值为当前的Handler，并且判断该Handler是否是异步消息（该种类型消息一般为系统创建），之后将消息通过queue.enqueueMessage加入到队列中
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
synchronized (this) {
//判断消息是否在使用中
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
//判断Looper是否已经退出
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;
//mMessage 始终标记的是MessageQueue链表的头
Message p = mMessages;
//线程是否需要唤醒
boolean needWake;
//如果p为null则表示MessageQueue为空，when = 0 表示该Message需要立即处理，
//when < p.when这个message的执行时间要小于MessageQueue中头的时间
//上述情况需要吧该消息加入链表头
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 {
//判断looper是否需要唤醒 mBlock为true表示Looper被阻塞，target为空，表示小时时同步屏障消息， msg.isAsynchronous表示msg是否为异步消息
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
//循环寻找链表插入的合适位置
for (;;) {
prev = p;
p = p.next;
//新Message的位置依赖于when的大小，最先执行的Message在队列的前面。
//该if语句是判断，循环是否已经到头，或者执行时间小于当前位置Message的时间，是便插入
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;
}
在queue.enqueueMessage中主要的代码就是插入msg的逻辑，分为两种情况，如果列表时空的则直接插到表头，否则就循环遍历链表，找到when的大小比当前位置小的链表项目，插入这个当前项的前面，如果找不到，插入到链表尾部
除此之外Handler还有两个插入消息的方法
public final boolean sendMessageAtFrontOfQueue(@NonNull Message msg)
public final boolean executeOrSendMessage(@NonNull Message msg)
sendMessageAtFrontOfQueue方法会发送一个when为0的消息，因为when为0，所以这个消息会直接插到队列同步，插队抢占别的消息执行的机会。 executeOrSendMessage方法会验证Handler调用的地方是否时自己的线程，如果是则直接执行消息，否则就把这个消息发送到对应的MessageQueue中，不过这个方法被@Hide修饰，没办法被调用
消息分发
消息的分发主要是Looper来进行，当调用Looper.looper()方法时，Looper开始遍历MessageQueue。
@SuppressWarnings("AndroidFrameworkBinderIdentity")
public static void loop() {
//循环遍历Looper
for (;;) {
if (!loopOnce(me, ident, thresholdOverride)) {
return;
}
}
}
上述方法最终调用MessageQueue中的next()方法
@UnsupportedAppUsage
Message next() {
//在调用dispose（）方法后mPtr变为0，该字段为0标志Looper已经被退出，并且不允许重启
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
//阻塞Looper进程，nextPollTimeoutMillis表示多长时间自动唤醒，
//nextPollTimeoutMillis为-1的时候需要主动唤醒Looper
//nextPollTimeoutMillis是最近可以运行的消息时间和开机时间戳的差值
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
//获取当前开机运行时间戳（设备深度睡眠不累加）
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
//优先处理同步屏障消息，当消息是同步屏障消息，会将MessageQueue中的异步消息取出来处理
if (msg != null && msg.target == null) {
//将MessageQueue中的异步消息取出来
//(msg != null && !msg.isAsynchronous())当msg不为空，且msg不为同步消息的时候继续循环，
//直到找到MessageQueu中的异步消息
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
//找到目标消息后，判断目标消息是否到了可以发送的时间
if (now < msg.when) {
//如果目标消息没到可以发送的时间，记录和当前时间的差值，并记录下来
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// 获取到消息，返回msg
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 {
//如果没有消息则让Looper阻塞并需要唤醒
nextPollTimeoutMillis = -1;
}
if (mQuitting) {
dispose();
return null;
}
//代码走到这边表示没有要处理的消息，Looper进入空闲时起
//查询是否有IdleHandler
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
//运行idler
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
pendingIdleHandlerCount = 0;
//在调用空闲处理程序时，可能已经传递了一条新消息，因此无需等待即可返回并再次查找未决消息。
nextPollTimeoutMillis = 0;
}
}
在上述代码中我们有几个关键的地方需要了解
如果消息中有同步屏障消息，那么Looper将会优先处理消息队列中的异步消息。如果没有消息需要处理，则会调用IdlerHandler，利用空闲片段处理空闲任务如果没有消息且没有IdlerHandler，Looper将会进入阻塞，释放CPU资源，并且需要主动唤醒
消息的处理
Looper在获取到需要处理的消息后，会调用msg.target.dispatchMessage(msg);来调用Handler中的dispatchMessage方法来处理消息
public void dispatchMessage(@NonNull Message msg) {
//首先判断msg是否设置了callBack
//Handler.post系列的方法，都是在msg中设置callback
if (msg.callback != null) {
handleCallback(msg);
} else {
//检测是Handler否设置了CallBack， 如果该回调返回true则不会继续调用handleMessage处理消息
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//调用handleMessage
handleMessage(msg);
}
}
消息分发的优先级
1.Message的回调方法：message.callback.run()，优先级最高 (Handler.post系列的方法都是给msg设置了callBack)
2.Handler的回调方法 Handler.mCallBack.handleMessage(msg)
val handler = Handler(Looper.getMainLooper()
) {
//返回true则表示拦截了消息，不会调用handleMessage来处理消息
true
}
3.Handler的默认方法：Handler.handleMessage(msg)
面试中遇到的Handler问题
为什么主线程不会因为Looper.loop()里的死循环卡死
主线程确实是通过Looper.loop()进入循环状态，因为这样主线程才不会像我们创建的一般线程一样，当可执行的代码执行完毕后，线程生命周期就被终止了。
在主线程中MessageQueue中没有可处理的消息是，便阻塞在MessageQueue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，知道新消息达到，所以主线程大多时候都处于休眠状态，并不会消耗大量CPU资源
这里采用的是Linux的epoll机制， 是一种IO多路复用机制，可以同时监控多个文件描述符，当某个文件描述符就绪，则立刻通知相应程序进行读或写操作拿到最新的消息，进而唤醒等待的线程。
2.post和snedMessage两类发送消息的方法有什么区别？
post一类的方法发送的Runable对象，但是其最后还是会被封装成Message对象，将Runable对象赋值给Message对象中的callBack变量，然后交由sendMessageAtTime()方法发送出去，在处理消息时，会在dispatchMessage()方法里首先被handleCallback(msg)方法执行.实际上就是执行了Message对象里Runable对象的run方法。 而sendMessage一类的方法发送的直接是Message对象，处理消息是，在dispatchMessage()里优先级会低于handleCallback(msg)方法，是通过自己重写的handleMessage(msg)方法来处理的。
3.为什么要通过Message.obtain()方法获取Message对象?
obtain()方法可以从全局消息池中得到一个空的Message对象，这样可以有效的节省系统资源。同时通过obtain各种重载方法还能获得一些Message拷贝，或对Message对象进行初始化。
4.Handler实现发送延迟消息的原理是什么
我们常用的postDelayed与sendMessageDelayed来发送延迟消息，其实最终都是将延迟时间转为确定时间，然后通过sendMessageAtTime()->enqueueMessage->queue.enqueueMessage这一系列方法将消息插入MessageQueue中，所以并不是延迟发送消息，而是直接发送消息，在借助MessageQueue的设计来实现消息的延迟处理。
消息延迟处理的原理涉及MessageQueue的两个静态方法next()和enqueueMessage（）通过native方法阻塞一段时间等到消息的执行时候在取出消息
5.同步屏障SyncBarrier是什么？有什么作用
在一般情况下，同步和异步消息处理没有什么不同，只有在设置了同步屏障消息后才会有差异，同步屏障消息的target为null，在messageQueue中如果当前消息是一个同步屏障消息，则会跳过后面所有同步消息，找到第一个异步消息来处理。但是开发者调用不了，在ViewRootImpl的UI测绘流程中有体现
6.IdleHandler是什么？有什么用？
当消息队列中没有需要处理的消息时调用（MessageQueue此时可能还有消息，但是不需要处理），会调用此方法，用以监听主线程空闲状态
7.为什么非静态类的Handler导致内存泄漏，如何解决
首先非静态类，匿名内部类，局部内部类都会隐式的持有外部类的引用，也就时说在Activity中创建的Handler会持有Activity引用。
当我们在主线程中使用Handler的时候，Handler会默认绑定这个线程的Looper对象，并关联其MessageQueue，Handler发出的消息都会加入到这个MessageQueue中，Looper对象的生命周期贯穿了整个主线程的生命周期，所以当Looper对象中的MessageQueue里还有未处理的Message时，因为每个Message都持有Handler的引用，所以Handler无法被回收，自然其持有引用的外部类Activity也无法回收，造成泄漏。
使用静态内部类 + 弱引用的方式
private static class StaticHandler extends Handler{
private WeakReference
public StaticHandler(Activity activity){
mWeakReference = new WeakReference<>(activity);
}
@Override
public void handleMessage(@NonNull Message msg) {
Activity activity = mWeakReference.get();
if(activity == null) return;
// todo 处理消息
}
}
8.如何让在子线程中弹出Toast
调用Looper.prepare以及Looper.loop()，但是切记线程任务执行玩，需要手动调用Looper.quitSafely()否则线程不会结束
参考文章
您阅读本篇文章共花了：
发表评论