• 一、消息机制概述
    • 1.消息机制的简介
    • 2.消息机制的模型
    • 3.消息机制的架构
  • 二、消息机制的源码解析
    • 1.Looper
      • 2.Handler
      • 3.发送消息
    • 4.获取消息
    • 5.分发消息
  • 三、总结

    一、消息机制概述

    1.消息机制的简介

    在Android中使用消息机制,我们首先想到的就是Handler。没错,Handler是Android消息机制的上层接口。Handler的使用过程很简单,通过它可以轻松地将一个任务切换到Handler所在的线程中去执行。通常情况下,Handler的使用场景就是更新UI。
    如下就是使用消息机制的一个简单实例:

    1. public class Activity extends android.app.Activity {
    2. private Handler mHandler = new Handler(){
    3. @Override
    4. public void handleMessage(Message msg) {
    5. super.handleMessage(msg);
    6. System.out.println(msg.what);
    7. }
    8. };
    9. @Override
    10. public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
    11. super.onCreate(savedInstanceState, persistentState);
    12. setContentView(R.layout.activity_main);
    13. new Thread(new Runnable() {
    14. @Override
    15. public void run() {
    16. ...............耗时操作
    17. Message message = Message.obtain();
    18. message.what = 1;
    19. mHandler.sendMessage(message);
    20. }
    21. }).start();
    22. }
    23. }

    在子线程中,进行耗时操作,执行完操作后,发送消息,通知主线程更新UI。这便是消息机制的典型应用场景。我们通常只会接触到Handler和Message来完成消息机制,其实内部还有两大助手来共同完成消息传递。

    2.消息机制的模型

    消息机制主要包含:MessageQueue,Handler和Looper这三大部分,以及Message,下面我们一一介绍。

    Message:需要传递的消息,可以传递数据;

    MessageQueue:消息队列,但是它的内部实现并不是用的队列,实际上是通过一个单链表的数据结构来维护消息列表,因为单链表在插入和删除上比较有优势。主要功能向消息池投递消息(MessageQueue.enqueueMessage)和取走消息池的消息(MessageQueue.next);

    Handler:消息辅助类,主要功能向消息池发送各种消息事件(Handler.sendMessage)和处理相应消息事件(Handler.handleMessage);

    Looper:不断循环执行(Looper.loop),从MessageQueue中读取消息,按分发机制将消息分发给目标处理者。

    3.消息机制的架构

    消息机制的运行流程:在子线程执行完耗时操作,当Handler发送消息时,将会调用MessageQueue.enqueueMessage,向消息队列中添加消息。当通过Looper.loop开启循环后,会不断地从线程池中读取消息,即调用MessageQueue.next,然后调用目标Handler(即发送该消息的Handler)的dispatchMessage方法传递消息,然后返回到Handler所在线程,目标Handler收到消息,调用handleMessage方法,接收消息,处理消息。

    Android消息机制 - 图1

    MessageQueue,Handler和Looper三者之间的关系:每个线程中只能存在一个Looper,Looper是保存在ThreadLocal中的。主线程(UI线程)已经创建了一个Looper,所以在主线程中不需要再创建Looper,但是在其他线程中需要创建Looper。每个线程中可以有多个Handler,即一个Looper可以处理来自多个Handler的消息。 Looper中维护一个MessageQueue,来维护消息队列,消息队列中的Message可以来自不同的Handler。

    Android消息机制 - 图2

    下面是消息机制的整体架构图,接下来我们将慢慢解剖整个架构。

    Android消息机制 - 图3

    从中我们可以看出:
    Looper有一个MessageQueue消息队列;
    MessageQueue有一组待处理的Message;
    Message中记录发送和处理消息的Handler;
    Handler中有Looper和MessageQueue。

    二、消息机制的源码解析

    1.Looper

    要想使用消息机制,首先要创建一个Looper。
    初始化Looper
    无参情况下,默认调用prepare(true);表示的是这个Looper可以退出,而对于false的情况则表示当前Looper不可以退出。。

    1. public static void prepare() {
    2. prepare(true);
    3. }
    4. private static void prepare(boolean quitAllowed) {
    5. if (sThreadLocal.get() != null) {
    6. throw new RuntimeException("Only one Looper may be created per thread");
    7. }
    8. sThreadLocal.set(new Looper(quitAllowed));
    9. }

    这里看出,不能重复创建Looper,只能创建一个。创建Looper,并保存在ThreadLocal。其中ThreadLocal是线程本地存储区(Thread Local Storage,简称为TLS),每个线程都有自己的私有的本地存储区域,不同线程之间彼此不能访问对方的TLS区域。
    开启Looper

    1. public static void loop() {
    2. final Looper me = myLooper(); //获取TLS存储的Looper对象
    3. if (me == null) {
    4. throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    5. }
    6. final MessageQueue queue = me.mQueue; //获取Looper对象中的消息队列
    7. Binder.clearCallingIdentity();
    8. final long ident = Binder.clearCallingIdentity();
    9. for (;;) { //进入loop的主循环方法
    10. Message msg = queue.next(); //可能会阻塞,因为next()方法可能会无限循环
    11. if (msg == null) { //消息为空,则退出循环
    12. return;
    13. }
    14. Printer logging = me.mLogging; //默认为null,可通过setMessageLogging()方法来指定输出,用于debug功能
    15. if (logging != null) {
    16. logging.println(">>>>> Dispatching to " + msg.target + " " +
    17. msg.callback + ": " + msg.what);
    18. }
    19. msg.target.dispatchMessage(msg); //获取msg的目标Handler,然后用于分发Message
    20. if (logging != null) {
    21. logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
    22. }
    23. final long newIdent = Binder.clearCallingIdentity();
    24. if (ident != newIdent) {
    25. }
    26. msg.recycleUnchecked();
    27. }
    28. }

    loop()进入循环模式,不断重复下面的操作,直到消息为空时退出循环:
    读取MessageQueue的下一条Message(关于next(),后面详细介绍);
    把Message分发给相应的target。

    当next()取出下一条消息时,队列中已经没有消息时,next()会无限循环,产生阻塞。等待MessageQueue中加入消息,然后重新唤醒。

    主线程中不需要自己创建Looper,这是由于在程序启动的时候,系统已经帮我们自动调用了Looper.prepare()方法。查看ActivityThread中的main()方法,代码如下所示:

    1. public static void main(String[] args) {
    2. ..........................
    3. Looper.prepareMainLooper();
    4. ..........................
    5. Looper.loop();
    6. ..........................
    7. }

    其中`prepareMainLooper()方法会调用prepare(false)方法。

    2.Handler

    创建Handler

    1. public Handler() {
    2. this(null, false);
    3. }
    4. public Handler(Callback callback, boolean async) {
    5. .................................
    6. //必须先执行Looper.prepare(),才能获取Looper对象,否则为null.
    7. mLooper = Looper.myLooper(); //从当前线程的TLS中获取Looper对象
    8. if (mLooper == null) {
    9. throw new RuntimeException("");
    10. }
    11. mQueue = mLooper.mQueue; //消息队列,来自Looper对象
    12. mCallback = callback; //回调方法
    13. mAsynchronous = async; //设置消息是否为异步处理方式
    14. }

    对于Handler的无参构造方法,默认采用当前线程TLS中的Looper对象,并且callback回调方法为null,且消息为同步处理方式。只要执行的Looper.prepare()方法,那么便可以获取有效的Looper对象。

    3.发送消息

    发送消息有几种方式,但是归根结底都是调用了sendMessageAtTime()方法。

    在子线程中通过Handler的post()方式或send()方式发送消息,最终都是调用了sendMessageAtTime()方法。

    post方法

    1. public final boolean post(Runnable r)
    2. {
    3. return sendMessageDelayed(getPostMessage(r), 0);
    4. }
    5. public final boolean postAtTime(Runnable r, long uptimeMillis)
    6. {
    7. return sendMessageAtTime(getPostMessage(r), uptimeMillis);
    8. }
    9. public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
    10. {
    11. return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
    12. }
    13. public final boolean postDelayed(Runnable r, long delayMillis)
    14. {
    15. return sendMessageDelayed(getPostMessage(r), delayMillis);
    16. }

    send方法

    1. public final boolean sendMessage(Message msg)
    2. {
    3. return sendMessageDelayed(msg, 0);
    4. }
    5. public final boolean sendEmptyMessage(int what)
    6. {
    7. return sendEmptyMessageDelayed(what, 0);
    8. }
    9. public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
    10. Message msg = Message.obtain();
    11. msg.what = what;
    12. return sendMessageDelayed(msg, delayMillis);
    13. }
    14. public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
    15. Message msg = Message.obtain();
    16. msg.what = what;
    17. return sendMessageAtTime(msg, uptimeMillis);
    18. }
    19. public final boolean sendMessageDelayed(Message msg, long delayMillis)
    20. {
    21. if (delayMillis < 0) {
    22. delayMillis = 0;
    23. }
    24. return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    25. }

    就连子线程中调用Activity中的runOnUiThread()中更新UI,其实也是发送消息通知主线程更新UI,最终也会调用sendMessageAtTime()方法。

    1. public final void runOnUiThread(Runnable action) {
    2. if (Thread.currentThread() != mUiThread) {
    3. mHandler.post(action);
    4. } else {
    5. action.run();
    6. }
    7. }

    如果当前的线程不等于UI线程(主线程),就去调用Handler的post()方法,最终会调用sendMessageAtTime()方法。否则就直接调用Runnable对象的run()方法。

    下面我们就来一探究竟,到底sendMessageAtTime()方法有什么作用?
    sendMessageAtTime()

    1. public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
    2. //其中mQueue是消息队列,从Looper中获取的
    3. MessageQueue queue = mQueue;
    4. if (queue == null) {
    5. RuntimeException e = new RuntimeException(
    6. this + " sendMessageAtTime() called with no mQueue");
    7. Log.w("Looper", e.getMessage(), e);
    8. return false;
    9. }
    10. //调用enqueueMessage方法
    11. return enqueueMessage(queue, msg, uptimeMillis);
    12. }
    1. private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    2. msg.target = this;
    3. if (mAsynchronous) {
    4. msg.setAsynchronous(true);
    5. }
    6. //调用MessageQueue的enqueueMessage方法
    7. return queue.enqueueMessage(msg, uptimeMillis);
    8. }

    可以看到sendMessageAtTime()`方法的作用很简单,就是调用MessageQueue的enqueueMessage()方法,往消息队列中添加一个消息。
    下面来看enqueueMessage()方法的具体执行逻辑。
    enqueueMessage()

    1. boolean enqueueMessage(Message msg, long when) {
    2. // 每一个Message必须有一个target
    3. if (msg.target == null) {
    4. throw new IllegalArgumentException("Message must have a target.");
    5. }
    6. if (msg.isInUse()) {
    7. throw new IllegalStateException(msg + " This message is already in use.");
    8. }
    9. synchronized (this) {
    10. if (mQuitting) { //正在退出时,回收msg,加入到消息池
    11. msg.recycle();
    12. return false;
    13. }
    14. msg.markInUse();
    15. msg.when = when;
    16. Message p = mMessages;
    17. boolean needWake;
    18. if (p == null || when == 0 || when < p.when) {
    19. //p为null(代表MessageQueue没有消息) 或者msg的触发时间是队列中最早的, 则进入该该分支
    20. msg.next = p;
    21. mMessages = msg;
    22. needWake = mBlocked;
    23. } else {
    24. //将消息按时间顺序插入到MessageQueue。一般地,不需要唤醒事件队列,除非
    25. //消息队头存在barrier,并且同时Message是队列中最早的异步消息。
    26. needWake = mBlocked && p.target == null && msg.isAsynchronous();
    27. Message prev;
    28. for (;;) {
    29. prev = p;
    30. p = p.next;
    31. if (p == null || when < p.when) {
    32. break;
    33. }
    34. if (needWake && p.isAsynchronous()) {
    35. needWake = false;
    36. }
    37. }
    38. msg.next = p;
    39. prev.next = msg;
    40. }
    41. if (needWake) {
    42. nativeWake(mPtr);
    43. }
    44. }
    45. return true;
    46. }

    MessageQueue是按照Message触发时间的先后顺序排列的,队头的消息是将要最早触发的消息。当有消息需要加入消息队列时,会从队列头开始遍历,直到找到消息应该插入的合适位置,以保证所有消息的时间顺序。

    4.获取消息

    当发送了消息后,在MessageQueue维护了消息队列,然后在Looper中通过loop()方法,不断地获取消息。上面对loop()方法进行了介绍,其中最重要的是调用了queue.next()方法,通过该方法来提取下一条信息。下面我们来看一下next()方法的具体流程。
    next()

    1. Message next() {
    2. final long ptr = mPtr;
    3. if (ptr == 0) { //当消息循环已经退出,则直接返回
    4. return null;
    5. }
    6. int pendingIdleHandlerCount = -1; // 循环迭代的首次为-1
    7. int nextPollTimeoutMillis = 0;
    8. for (;;) {
    9. if (nextPollTimeoutMillis != 0) {
    10. Binder.flushPendingCommands();
    11. }
    12. //阻塞操作,当等待nextPollTimeoutMillis时长,或者消息队列被唤醒,都会返回
    13. nativePollOnce(ptr, nextPollTimeoutMillis);
    14. synchronized (this) {
    15. final long now = SystemClock.uptimeMillis();
    16. Message prevMsg = null;
    17. Message msg = mMessages;
    18. if (msg != null && msg.target == null) {
    19. //当消息Handler为空时,查询MessageQueue中的下一条异步消息msg,为空则退出循环。
    20. do {
    21. prevMsg = msg;
    22. msg = msg.next;
    23. } while (msg != null && !msg.isAsynchronous());
    24. }
    25. if (msg != null) {
    26. if (now < msg.when) {
    27. //当异步消息触发时间大于当前时间,则设置下一次轮询的超时时长
    28. nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
    29. } else {
    30. // 获取一条消息,并返回
    31. mBlocked = false;
    32. if (prevMsg != null) {
    33. prevMsg.next = msg.next;
    34. } else {
    35. mMessages = msg.next;
    36. }
    37. msg.next = null;
    38. //设置消息的使用状态,即flags |= FLAG_IN_USE
    39. msg.markInUse();
    40. return msg; //成功地获取MessageQueue中的下一条即将要执行的消息
    41. }
    42. } else {
    43. //没有消息
    44. nextPollTimeoutMillis = -1;
    45. }
    46. //消息正在退出,返回null
    47. if (mQuitting) {
    48. dispose();
    49. return null;
    50. }
    51. ...............................
    52. }
    53. }

    nativePollOnce是阻塞操作,其中nextPollTimeoutMillis代表下一个消息到来前,还需要等待的时长;当nextPollTimeoutMillis = -1时,表示消息队列中无消息,会一直等待下去。
    可以看出next()方法根据消息的触发时间,获取下一条需要执行的消息,队列中消息为空时,则会进行阻塞操作。

    5.分发消息

    在loop()方法中,获取到下一条消息后,执行msg.target.dispatchMessage(msg),来分发消息到目标Handler对象。
    下面就来具体看下dispatchMessage(msg)方法的执行流程。
    dispatchMessage()

    1. public void dispatchMessage(Message msg) {
    2. if (msg.callback != null) {
    3. //当Message存在回调方法,回调msg.callback.run()方法;
    4. handleCallback(msg);
    5. } else {
    6. if (mCallback != null) {
    7. //当Handler存在Callback成员变量时,回调方法handleMessage();
    8. if (mCallback.handleMessage(msg)) {
    9. return;
    10. }
    11. }
    12. //Handler自身的回调方法handleMessage()
    13. handleMessage(msg);
    14. }
    15. }
    1. private static void handleCallback(Message message) {
    2. message.callback.run();
    3. }

    分发消息流程:
    当Message的msg.callback不为空时,则回调方法msg.callback.run();
    当Handler的mCallback不为空时,则回调方法mCallback.handleMessage(msg)
    最后调用Handler自身的回调方法handleMessage(),该方法默认为空,Handler子类通过覆写该方法来完成具体的逻辑。

    消息分发的优先级:
    Message的回调方法:message.callback.run(),优先级最高;
    Handler中Callback的回调方法:Handler.mCallback.handleMessage(msg),优先级仅次于1;
    Handler的默认方法:Handler.handleMessage(msg),优先级最低。

    对于很多情况下,消息分发后的处理方法是第3种情况,即Handler.handleMessage(),一般地往往通过覆写该方法从而实现自己的业务逻辑。

    三、总结

    以上便是消息机制的原理,以及从源码角度来解析消息机制的运行过程。可以简单地用下图来理解。

    Android消息机制 - 图4