Handler源码分析

Handler

引言

Handler是为了解决非UI线程中UI更新的问题,这里会产生一个疑问。为啥要在UI线程中更新,一般都知道会产生卡顿问题。

基本概念

上张官方关系类图,压压惊:

可以看到他有四个子类,前面两个是与异步数据库操作相关的(contentProvider),后面两个是与网络请求(一个是处理http授权,另一个是处理SSL错误请求)

MessageQueue与Message,Looper,Handler

Handler作为入口

Handler 主要功能是发送消息和处理接受消息。一般常用的 handler.sendEmptyMessage(int what)sendMessage(Message msg) 方法,下面就从 sendEmptyMessage(int what) 方法看看它是怎么运作的?

sendEmptyMessage 内部调用关系如下:

sendEmptyMessage => sendEmptyMessageDelayed => sendMessageDelayed => enqueueMessage

    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        //构造新的消息 使用sPool全局池保存回收的消息链表进行空消息缓存 
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }
    ...
   public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }
    ...
    public boolean sendMessageAtTime(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);
    }
    ...
 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

疑问:

  • obtain(奥普摊)方法是如何构造消息的?看了后发现recycle与之相关的。
  • 这里发现产生的 uptimeMillis没有被用到,那他是用来干什么的?(uptimeMillis是开机到现在的毫秒数,内部实现是一个native方法 )
  • 设置 msg.setAsynchronous 怎么使用其值?

obtain方法如何构造消息的以及recycle方法的作用

看了obtain方法后发现,sPool默认是static,所以属于Message类,共享的,没有初始化,那它什么时候进行赋值。答案就在recycle方法,顾名思义其实作用相当于回收那些没用的消息,那这个是怎么工作的?

  ...
  //recycle内部调用的recycleUnchecked函数
  void recycleUnchecked() {
        // Mark the message as in use while it remains in the recycled object pool.
        // Clear out all other details.
        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++;
            }
        }
    }

可以自己纸上画下,下面看图说话:

  private static final Object sPoolSync = new Object();
  private static Message sPool;
  private static int sPoolSize = 0;

  private static final int MAX_POOL_SIZE = 50;
  ...
  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();
    }

直接上图:

  • 总结来说,其实生成新消息是取用了类似单链表的全局池,有个前提条件是已经有消息调用recycle方法,不然生成的消息都是new出来的。

MessageQueue 干了啥

概括:MessageQueue中使用一个单链表来维护消息队列。通过Looper对象分发消息,但是不能直接把Message入队,需要通过Looper关联的Handler来发送消息。

关键看两个方法:enqueueMessage 与 next(后续分析) 方法,前面一个是消息入队,后面一个是消息出队。

先来看看 enqueueMessage 方法,首先它有两个参数:消息--msg 和触发时间--when,简单来说,如果p为空的话直接赋值 mMessages = msg,如果p不为空的话则需要根据触发时间--when插入到链表合适的位置。

  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) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
               ...
                //关键代码
                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;
    }
  • 先看下新消息需要放到队头的情况:p == null || when == 0 || when < p.when。即队列为空,或者新消息需要立即处理,或者新消息处理的事件比队头消息更早被处理。这时只要让新消息的next指向当前队头,让mMessages指向新消息即可完成插入操作。
  • 除了上面情况之外,需要遍历链表并比较when的值,由于这个链表根据when时间从小到大的,只要找到第一个链表节点的when比插入消息的when大或者没找到,跳出循环,并插入链表。

Looper类

prepare()

Looper的构造函数修饰符是private的,那么他是在哪里被实例化?通过搜索,发现 prepare()prepareMainLooper()两个方法。

  • prepare()方法官方说明; 作为looper初始化当前线程。提供一个机会来创建handler并使用looper。在使用之前,请在此方法之后调用loop(),并在结束时调用quit()
  • prepareMainLooper()方法官方说明; 作为looper初始化当前线程,并标记其为application主线程的looper。在application主线程中的looper被Android系统创建,因此开发者请永远不要手动调用这个方法。 public static void prepareMainLooper() { prepare(false); synchronized (Looper.class) { if (sMainLooper != null) { throw new IllegalStateException("The main Looper has already been prepared."); } sMainLooper = myLooper(); } } private static void prepare(boolean quitAllowed) { if (sThreadLocal.get() != null) { throw new RuntimeException("Only one Looper may be created per thread"); } sThreadLocal.set(new Looper(quitAllowed)); } 看上面的prepareMainLooper()代码,发现做了两个事: prepare(false)myLooper()
  • prepare(false)方法中的sThreadLocal字段的类型是 ThreadLocal,用来干什么呢?实现一个线程本地存储,一个让每个线程都有拥有value的变量。另外,可以看看构造函数Looper干了些什么事情? private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }
  • 对于myLooper()来说,prepare()中提到了会将looper放到线程存储ThreadLocal中,此处只需要从中取出并返回即可,因此代码只有一行return sThreadLocal.get();
  • 疑问 在activity当中实例的Handler,我们并没有调用loop方法?

查看prepareMainLooper()调用者可以看到,在SystemServer.run()与ActivityThread.main()中都在调用Looper.prepareMainLooper()后不远就调用了Looper.loop()。而这两处可以推断一个是系统应用的主线程,一个是用户应用的主线程,而后面这个就是答案。

loop()

  • loop主要是通过死循环来重复做某件事的方法。
  public static void loop() {
        final Looper me = myLooper();
        final MessageQueue queue = me.mQueue;
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                return;
            }
            msg.target.dispatchMessage(msg);
            msg.recycleUnchecked();
        }
    }

这里就一目了然了:一个死循环,不断从队列中取消息并分发,如果取到null就说明消息队列已经退出或被释放,此时loop终止。msg.target.dispatchMessage(msg)中target便是在发送消息的handler对象,dispatchMessage()便是对消息的处理了。

总结

  • 上面几个基本概念的关系如下图:

参考资源

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏IT开发技术与工作效率

VBA非登陆下载Excel文件并处理例子

15840
来自专栏码匠的流水账

ConcurrentLinkedQueue使用实例

ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列,它采用先进先出的规则对节点进行排序,当我们添加一个元素的时候,它会添加到队列的尾...

24730
来自专栏Android 研究

Android Handler机制3之SystemClock类

官网位置在https://developer.android.com/reference/android/os/SystemClock.html

20320
来自专栏everhad

笔记:安卓App消息处理机制

内容简述 类似Binder机制,MessageQueue、Looper也有底层的C++实现,涉及文件管道和驱动等。 以下仅从Java层的Looper、Hand...

20270
来自专栏雪胖纸的玩蛇日常

Uncaught SyntaxError: Unexpected token ' in JSON at position 1

1.5K30
来自专栏菩提树下的杨过

jQuery扩展以及gzip压缩测试

<!doctype html> <html> <head> <meta http-equiv="content-type" content="text/h...

29850
来自专栏子勰随笔

URL编码中的空格(编码以后变为+)

294100
来自专栏SDNLAB

源码解读ODL的MAC地址学习(一)

1 简介 我们知道同一子网中主机之间互相传送信息需要用到MAC地址,而我们第一次发送信息的时候只有IP地址而没有MAC地址,所以我们就要进行MAC地址自学习。 ...

82060
来自专栏菩提树下的杨过

rpc框架之 thrift连接池实现

接前一篇rpc框架之HA/负载均衡构架设计 继续,写了一个简单的thrift 连接池: 先做点准备工作: package yjmyzz; public cla...

69280
来自专栏Android 研究

Android Handler机制6之MessageQueue简介

我们知道MessageQueue就一个构造函数 代码在MessageQueue.java 68行

13120

扫码关注云+社区

领取腾讯云代金券