Android Handler 消息机制(解惑篇)

Android中的消息处理机制概述

大家对于Android中的消息处理机制的用法一定都比较熟悉,至于工作原理估计不少人有研究。就像我们自己写的类我们用起来比较熟悉一样,如果我们熟悉了消息处理机制的具体实现,那么我们用起来肯定也会事半功倍。

博主之前只是稍有涉猎,对其中一些地方也还心存疑虑,比如既然Looper.loop()里是一个死循环,那它会不会很消耗CPU呢?死循环阻塞了线程,那我们其他的事务是如何被处理的呢?Android的UI线程是在哪里被初始化的呢?等等。索性今天就把他们放到一起,说道说道。

Android中线程的分类

  • 带有消息队列,用来执行循环性任务(例如主线程、android.os.HandlerThread)
    • 有消息时就处理
    • 没有消息时就睡眠
  • 没有消息队列,用来执行一次性任务(例如java.lang.Thread)
    • 任务一旦执行完成便退出

带有消息队列线程概述

四要素

  • Message(消息)
  • MessageQueue(消息队列)
  • Looper(消息循环)
  • Handler(消息发送和处理)

四要素的交互过程

具体工作过程

  • 消息队列的创建
  • 消息循环
  • 消息的发送最基本的两个API
    • Handler.sendMessage
      • 带一个Message参数,用来描述消息的内容
    • Handler.post
      • 带一个Runnable参数,会被转换为一个Message参数
  • 消息的处理

基于消息的异步任务接口

  • android.os.HandlerThread
    • 适合用来处于不需要更新UI的后台任务
  • android.os.AyncTask
    • 适合用来处于需要更新UI的后台任务

带有消息队列线程的具体实现

ThreadLocal

ThreadLocal并不是一个Thread,而是Thread的局部变量。当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每一个线程都可以独立地改变自己的副本,而不会影响其它线程所对应的副本。

从线程的角度看,目标变量就象是线程的本地变量,这也是类名中“Local”所要表达的意思。

Looper

用于在指定线程中运行一个消息循环,一旦有新任务则执行,执行完继续等待下一个任务,即变成Looper线程。Looper类的注释里有这样一个例子:

其实核心代码就两行,我们先来看下Looper.prepare()方法的具体实现

从中我们可以看到以下几点:

  • prepare()其核心就是将looper对象定义为ThreadLocal
  • 一个Thread只能有一个Looper对象
  • prepare()方法会调用Looper的构造方法,初始化一个消息队列,并且指定当前线程
  • 在调用Looper.loop()方法之前,确保已经调用了prepare(boolean quitAllowed)方法,并且我们可以调用quite方法结束循环

说到初始化MessageQueue,我们来看下它是干什么的

/**
* Low-level class holding the list of messages to be dispatched by a
* {@link Looper}. Messages are not added directly to a MessageQueue,
* but rather through {@link Handler} objects associated with the Looper.
*
*

You can retrieve the MessageQueue for the current thread with
* {@link Looper#myQueue() Looper.myQueue()}.
*/

它是一个低等级的持有Messages集合的类,被Looper分发。Messages并不是直接加到MessageQueue的,而是通过Handler对象和Looper关联到一起。我们可以通过Looper.myQueue()方法来检索当前线程的MessageQueue。

接下来再看看Looper.loop()

通过这段代码可知,调用loop方法后,Looper线程就开始真正工作了,它不断从自己的MessageQueue中取出队头的消息(或者说是任务)执行

除了prepare()和loop()方法,Looper类还有一些比较有用的方法,比如

  • Looper.myLooper()得到当前线程looper对象
  • getThread()得到looper对象所属线程
  • quit()方法结束looper循环这里需要注意的一点是,quit()方法其实调用的是MessageWueue的quite(boolean safe)方法。

    我们看到其实主线程是不能调用这个方法退出消息队列的。至于mQuitAllowed参数是在Looper初始化的时候初始化的,主线程初始化调用的是Looper.prepareMainLooper()方法,这个方法把参数设置为false。

Message

在整个消息处理机制中,message又叫task,封装了任务携带的信息和处理该任务的handler。我们看下这个类的注释

/**
*
* Defines a message containing a description and arbitrary data object that can be
* sent to a {@link Handler}. This object contains two extra int fields and an
* extra object field that allow you to not do allocations in many cases.
*
*

While the constructor of Message is public, the best way to get
* one of these is to call {@link #obtain Message.obtain()} or one of the
* {@link Handler#obtainMessage Handler.obtainMessage()} methods, which will pull
* them from a pool of recycled objects.

*/

这个类定义了一个包含描述和一个任意类型对象的对象,它可以被发送给Handler。

从注释里我们还可以了解到以下几点:

  • 尽管Message有public的默认构造方法,但是你应该通过Message.obtain()来从消息池中获得空消息对象,以节省资源。
  • 如果你的message只需要携带简单的int信息,请优先使用Message.arg1和Message.arg2来传递信息,这比用Bundle更省内存
  • 用message.what来标识信息,以便用不同方式处理message。

Handler

从MessageQueue的注释中,我们知道添加消息到消息队列是通过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.
*
*

There are two main uses for a Handler: (1) to schedule messages and
* runnables to be executed as some point in the future; and (2) to enqueue
* an action to be performed on a different thread than your own.
*
*/

注释比较简单,这里就不过多翻译了,主要内容是:每一个Handler实例关联了一个单一的ghread和这个thread的messagequeue,当Handler的实例被创建的时候它就被绑定到了创建它的thread。它用来调度message和runnables在未来某个时间点的执行,还可以排列其他线程里执行的操作。

先看构造方法,其实里边的重点是初始化了两个变量,把关联looper的MessageQueue作为自己的MessageQueue,因此它的消息将发送到关联looper的MessageQueue上

有了handler之后,我们就可以使用Handler提供的post和send系列方法向MessageQueue上发送消息了。其实post发出的Runnable对象最后都被封装成message对象

接下来我们看一下handler是如何发送消息的

这里我们只列出了一种调用关系,其他调用关系大同小异,我们来分析一下

  1. 调用getPostMessage(r),把runnable对象添加到一个Message对象中。
  2. sendMessageDelayed(getPostMessage(r), 0),基本没做什么操作,又继续调用sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)方法,在这个方法里拿到创建这个Handler对象的线程持有的MessageQueue。
  3. 调用enqueueMessage(queue, msg, uptimeMillis)方法,给msg对象的target变量赋值为当前的Handler对象,然后放入到MessageQueue。

那发送消息说完了,那我们的消息是怎样被处理的呢?

我们看到message.target为该handler对象,这确保了looper执行到该message时能找到处理它的handler,即loop()方法中的关键代码。

我们看到这里最终又调用到了我们重写的handleMessage(Message msg)方法来做处理子线程发来的消息或者调用handleCallback(Message message)去执行我们子线程中定义并传过来的操作。

思考

为什么要有Handler机制

这个问题可以这么考虑

  1. 我们如何在子线程更新UI?——使用Handler机制传递消息到主线程(UI线程)
  2. 为什么我们不在子线程更新UI呢?——因为Android是单线程模型
  3. 为什么要做成单线程模型呢?——多线程并发访问UI可能会导致UI控件处于不可预期的状态。如果加锁,虽然能解决,但是缺点也很明显:1.锁机制让UI访问逻辑变得复杂;2.加锁导致效率低下。

Handler机制与命令模式

我在之前分享过Android源码中的命令模式,我们仔细分下一下不难看出Handler机制其实是一个非典型的命令模式

  • 接收者:Handler,执行消息处理操作。
  • 调用者:Looper,调用消息的的处理方法。
  • 命令角色:Message,消息类。
  • 客户端:Thread,创建消息并绑定Handler(接受者)。

Android主线程是如何管理子线程消息的

我们知道Android上一个应用的入口,应该是ActivityThread。和普通的Java类一样,入口是一个main方法。

我们可以看到其实我们在这里初始化了我们主线程(UI)的Looper并且启动它。然后就可以处理子线程和其他组件发来的消息了。

为什么主线程不会因为Looper.loop()里的死循环卡死或者不能处理其他事务

这里涉及到的东西比较多,概括的理解是这样的

  1. 为什么不会卡死handler机制是使用pipe来实现的,主线程没有消息处理时会阻塞在管道的读端。

    binder线程会往主线程消息队列里添加消息,然后往管道写端写一个字节,这样就能唤醒主线程从管道读端返回,也就是说queue.next()会调用返回。

    主线程大多数时候都是处于休眠状态,并不会消耗大量CPU资源。

  2. 既然是死循环又如何去处理其他事务呢?答案是通过创建新线程的方式

    我们看到main方法里调用了thread.attach(false),这里便会创建一个Binder线程(具体是指ApplicationThread,Binder的服务端,用于接收系统服务AMS发送来的事件),该Binder线程通过Handler将Message发送给主线程。

    ActivityThread对应的Handler是一个内部类H,里边包含了启动Activity、处理Activity生命周期等方法。

参考资料

http://www.cnblogs.com/codingmyworld/archive/2011/09/12/2174255.html

http://czpsailer.iteye.com/blog/655942

https://www.zhihu.com/question/34652589

打赏支持我写出更多好文章,谢谢!

打赏作者

打赏支持我写出更多好文章,谢谢!

任选一种支付方式

2 7 收藏 评论

关于作者:PleaseCallMeCoder

我是 PleaseCallMeCoder,一个小小的90后程序员。热衷于移动开发,喜欢研究新技术,奔跑在成为大神的路上。 个人主页 · 我的文章 · 29 ·   

可能感兴趣的话题



直接登录
跳到底部
返回顶部