您的位置 首页 java

Handler 源码解析(Java 层)

智云科技发布于 2023年2月5日评论关闭阅读(136)

本文由船员 ChangeHui 自荐，转载发布

从很早开始就认识到 Handler 了，只不过那时修为尚浅，了解的不够深刻，也没有应用自如。不过随着工作时间的增长，对 Handler 又有了更深层次的认识，于是有了这篇博客，希望尽可能的总结出多的知识点。

Handler 在 Java 层源码主要有 4 个类：Looper、MessageQueue、Message、Handler。我归纳了他们的几个主要知识点：

  • Looper：sThreadLocal、Looper.loop()；
  • Message：数据结构、消息缓存池；
  • MessageQueue：enqueueMessage、next、管道等待、同步消息隔离、idleHandler；
  • Handler：send/post、dispatchMessage 消息处理优先级。

Looper

Looper 数据结构 

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper; // guarded by Looper.class
final MessageQueue mQueue;
// sThreadLocal
private static void prepare(boolean quitAllowed) {
 if (sThreadLocal.get() != null) { throw Exception ... }
 sThreadLocal.set(new Looper(quitAllowed));
}
public static @Nullable Looper myLooper() {
 return sThreadLocal.get();
}
// sMainLooper
public static void prepareMainLooper() {
 prepare(false);
  synchronized  (Looper.class) {
 if (sMainLooper != null) { throw Exception ...}
 sMainLooper = myLooper();
 }
}
public static Looper getMainLooper() {
 synchronized (Looper.class) {
 return sMainLooper;
 }
}
// mQueue
private Looper(boolean quitAllowed) {
 mQueue = new MessageQueue(quitAllowed);
 mThread = Thread.currentThread();
}
public static @NonNull MessageQueue myQueue() {
 return myLooper().mQueue;
}

  • sThreadLocal：静态常量，保证一个 线程 只有一个 Looper；
  • sMainLooper：静态变量，在 prepareMainLooper 中赋值当前线程 Looper；
  • mQueue：变量，Looper 构造函数中初始化，因为一个线程只有一个 Looper，所以也同样只有一个 mQueue。

通过以上分析，我们可以总结出一下特性：

  1. Looper、MessageQueue 是线程唯一的；
  2. 一个进程只有一个 sMainLooper；
  3. 根据 ThreadLocal 的特性，可通过 myLooper 方法获取当前线程的 Looper。

Looper.loop() 

public static void loop() {
 final Looper me = myLooper();
 final MessageQueue queue = me.mQueue;
 for (;;) { 
 Message  msg  = queue.next();
 ...
 msg.target.dispatchMessage(msg);
 ...
 msg.recycleUnchecked();
 }
}

Looper.loop() 方法虽然看起来很多，其实他主要就做了三件事：

  1. 从消息队列中获取下一个消息；
  2. msg.target 就是 handler，通过 dispatchMessage 方法把消息分发下去，这个方法下面会有说到；
  3. 消息回收，放到消息缓存池里。这里需要注意的是 Message 对象并没有释放，会缓存起来。

Message

Message 数据结构 

public int what, arg1, arg2;
public Object obj;
public Messenger replyTo;
int  flags ;
long when; // 消息发送时间
Bundle data;
Handler target;
Runnable callback;
Message next;
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;

  • 看到 next 变量，我们会想到 单链表 ，其实 Message 就相当于单链表的 node，MessageQueue 就是一个单链表了，会持有表头的引用；
  • what、arg1、arg2、obj、data 就是我们发送的一些信息；
  • 值得注意的是 target，他是 Handler 类型，就是本消息的 Handler，会在 Handler 发送消息的时候赋值；
  • 后面的四个对象，都是和消息缓存池有关的。

Message 消息缓存池 

public static Message obtain() {
 synchronized (sPoolSync) {
 if (sPool != null) {
 Message m = sPool;
 sPool = m.next;
 m.next = null;
 m.flags = 0; // clear in-use flag
 sPoolSize--;
 return m;
 }
 }
 return new Message();
}
void recycleUnchecked() {
 flags = FLAG_IN_USE;
 what = 0;
 arg1 = 0;
 arg2 = 0;
 obj = null;
 replyTo = null;
 sendingUid = -1;
 when = 0;
 target = null;
 callback = null;
 data = null;
 synchronized (sPoolSync) {
 if (sPoolSize < MAX_POOL_SIZE) {
 next = sPool;
 sPool = this;
 sPoolSize++;
 }
 }
}

  • 事实上缓存池的数据结构也是一个链表，sPool 为链表头引用，最大容量为 50；
  • 回收消息时，会把消息里面所有参数重置，并把当前消息设为链表头；
  • 获取消息时，返回当前链表头，并把 next 置空。

MessageQueue

插入队列 

boolean enqueueMessage(Message msg, long when) {
 synchronized (this) {
 msg.markInUse();
 msg.when = when;
 Message p = mMessages;
 boolean needWake;
 if (p == null || when == 0 || when < p.when) {
 // 作为表头，如果队列是阻塞状态则需要唤醒
 msg.next = p;
 mMessages = msg;
 needWake = mBlocked;
 } else {
 // 根据时间顺序，插入链表中间
 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; // 插入消息
 prev.next = msg;
 }
 // We can assume mPtr != 0 because mQuitting is false.
 if (needWake) {
 nativeWake(mPtr);
 }
 }
 return true;
}

主要作为插入队列的方法，有下列几个特性：

  • 把消息加入消息队列，如果当前表头为空，则把消息作为表头引用；如果不为空，则会根据时间的顺序，插入到对应的时间中；
  • nativeWake 是调用底层在管道中写操作以唤醒，在队列不是阻塞的状态下是不需要唤醒的；
  • 另外注意其中用了 synchronized 关键字，说明消息队列的插入是线性安全的，删除也是线性安全的，之后我们会说到。

MessageQueue.next() 

for (;;) {
 nativePollOnce(ptr, nextPollTimeoutMillis);
 synchronized (this) {
 final long now = SystemClock.uptimeMillis();
 Message prevMsg = null;
 Message msg = mMessages;
 if (msg != null && msg.target == null) {
 // 如果有同步消息隔离，则会优先查找异步消息
 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 {
 // Got a message.
 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 {
 // 没有更多消息的时候，nextPollTimeoutMillis 会置为 1。
 nextPollTimeoutMillis = -1;
 }
 ...
 }
 // 如果目前没有消息，已经处在空闲状态，则执行 idler.queueIdle
 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 {
 keep = idler.queueIdle();
 } catch (Throwable t) {
 Log.wtf(TAG, "IdleHandler threw exception", t);
 }
 if (!keep) {
 synchronized (this) {
 mIdleHandlers.remove(idler);
 }
 }
 }
 ...
}

此方法会从消息队列中读取下一个消息返回，主要做了以下操作：

  • nativePollOnce 函数会调用底层管道操作函数，nextPollTimeoutMillis 为 -1 时，会阻塞，为 0 时不会阻塞，大于 0 时，会阻塞相应的时间；
  • 如果有同步消息隔离，则会优先查找异步消息；
  • 获取当前时间队列的消息，并返回；
  • 如果队列没有任何消息，则会执行 idler.queueIdle，通知监听者当前队列处于空闲状态。

同步消息隔离

上面我们有提到了同步消息隔离，这里我们介绍一下。同步隔离，有时候也可以叫异步消息，说的是一个意思。在源码中主要用于优先更新 UI。 

private IdleHandler[] mPendingIdleHandlers;
public int postSyncBarrier() {
 return postSyncBarrier(SystemClock.uptimeMillis());
}
private int postSyncBarrier(long when) {
 // 向消息队列中加入一个 handler 为空的消息
 synchronized (this) {
 final int token = mNextBarrierToken++;
 final Message msg = Message.obtain();
 msg.markInUse();
 msg.when = when;
 msg.arg1 = token;
 Message prev = null;
 Message p = mMessages;
 if (when != 0) {
 while (p != null && p.when <= when) {
 prev = p;
 p = p.next;
 }
 }
 if (prev != null) { // invariant: p == prev.next
 msg.next = p;
 prev.next = msg;
 } else {
 msg.next = p;
 mMessages = msg;
 }
 return token;
 }
}

如上 postSyncBarrier 函数中会向消息队列中加入一个 handler(即 Message 的 target) 为空的消息作为标识。在我们上面 MessageQueue.next() 的函数中，当 msg.target == null 时，会优先获取异步消息并返回。

因此想要使用异步消息有两个条件：

  1. 消息为异步消息，即 msg.isAsynchronous() 返回 false；
  2. 需要获取当前队列并运行 postSyncBarrier() 函数。

IdleHandler

Handler 还提供了消息队列空闲状态通知。 

private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
public void addIdleHandler(@NonNull IdleHandler handler) {
 if (handler == null) {
 throw new NullPointerException("Can't add a null IdleHandler");
 }
 synchronized (this) {
 mIdleHandlers.add(handler);
 }
}
public void removeIdleHandler(@NonNull IdleHandler handler) {
 synchronized (this) {
 mIdleHandlers.remove(handler);
 }
}

IdleHandler 的源码比较简单，就是一个 ArrayList，然后进行增加删除操作。注意，这个也是线性安全的。

Handler

post/ sendMessage 

public final boolean post(Runnable r){
 return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean sendMessage(Message msg){
 return sendMessageDelayed(msg, 0);
}
private static Message getPostMessage(Runnable r) {
 Message m = Message.obtain();
 m.callback = r;
 return m;
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
 msg.target = this;
 if (mAsynchronous) {
 msg.setAsynchronous(true);
 }
 return queue.enqueueMessage(msg, uptimeMillis);
}
  • sendMessage 和 post 最本质的区别是之后处理任务时的优先级，post 会处理 Runnable 中的任务，而 sendMessage 会回调给 handler 处理；
  • 他们最终都会走 enqueueMessage 方法，并设置当前 Handler 为 msg.target。

dispatchMessage 

public void dispatchMessage(Message msg) {
 if (msg.callback != null) {
 handleCallback(msg);
 } else {
 if (mCallback != null) {
 if (mCallback.handleMessage(msg)) {
 return;
 }
 }
 handleMessage(msg);
 }
}

任务执行时就会运行这个函数，主要是一个优先级的问题：

  1. callback 优先级最高，也就是 post 发送的消息
  2. mCallback.handleMessage(msg)，优先级第二
  3. handleMessage(msg)，优先级第三

（原文完）

祝大家周末愉快，下周见。

标签:
打赏 点赞(1)

文章来源：智云一二三科技

文章标题：Handler 源码解析(Java 层)

文章地址：https://www.zhihuclub.com/199243.shtml

关于作者: 智云科技

相关文章

热门文章

1分享新浪图床上传接口源码

点赞(909)阅读(60,247)

2PHP简单实现路由Route功能

点赞(1.13K)阅读(35,951)

3Tideways、xhprof 和 xhgui 打造 PHP 非侵入式监控平台

点赞(335)阅读(4,280)

4centos系统如何查看是否安装了mysql

点赞(510)阅读(3,769)

5curl 工具简述

点赞(479)阅读(2,964)
网站地图