从源码角度分析Android的消息机制

前言

说到Android的消息机制,那么主要的就是指的Handler的运行机制。其中包括MessageQueue以及Looper的工作过程。

在开始正文之前,先抛出两个问题:

  1. 为什么更新UI的操作要在主线程中进行?
  2. Android中为什么主线程不会因为Looper.loop()里的死循环卡死?

UI线程的判断是在ViewRootImpl中的checkThread方法中完成的。

对于第一个问题,这里给一个简单的回答:

如果可以在子线程中修改UI,多线程的并发访问可能会导致UI控件的不可预期性,采用加锁的方式,就会降低UI的访问效率以及会阻塞其他线程的执行,所以最简单有效的方法就是采用单线程模型来处理UI操作。

Handler的运行离不来底层的MessageQueue和Looper的支撑。MessageQueue翻译过来是一个消息队列,里面存储了Handler需要的Message,MessageQueue并不是一个队列,其实上是用单链表的数据结构来存储Message。

那么Handler如何拿到Message呢?这时候就需要Looper了,Looper通过Looper.loop()来开启一个死循环,不断从MessageQueue中取消息然后传递给Handler。

这里还有另一个知识点就是Looper的获取,这里就要提高一个存储类:ThreadLocal

ThreadLocal的工作原理

ThreadLocal是线程内部的一个数据存储类,可以存储某个线程中的数据,对于其他线程无法获取该线程的数据。我们通过原理来看一下,这个观点是否正确。

 public void set(T value) {
  Thread t = Thread.currentThread();
  ThreadLocalMap map = getMap(t);
  if (map != null)
   map.set(this, value);
  else
   createMap(t, value);
 }

  public T get() {
  Thread t = Thread.currentThread();
  ThreadLocalMap map = getMap(t);
  if (map != null) {
   ThreadLocalMap.Entry e = map.getEntry(this);
   if (e != null) {
    @SuppressWarnings("unchecked")
    T result = (T)e.value;
    return result;
   }
  }
  return setInitialValue();
 }

可以看出它的set和get方法就是在当前线程中所做的操作,ThreadLocalMap内部是一个数组table。 这样就保证了在不同线程中的数据互不干扰。

ThreadLocal除了使用在Handler中获取Looper,还用于一些复杂的场景,比如:监听器的传递。

我们简单了解了ThreadLocal,那么我们从New Handler()来一步步梳理下消息机制。

Looper的工作原理

// Handler.java

 public Handler() {
  this(null, false);
 }
 // callback 消息回调;async 是否同步
 public Handler(Callback callback, boolean async) {
  ...
  // 1. 首先获取looper
  mLooper = Looper.myLooper();
  if (mLooper == null) {
   throw new RuntimeException(
    "Can't create handler inside thread " + Thread.currentThread()
      + " that has not called Looper.prepare()");
  }
  // 2. 获取MessggeQueue
  mQueue = mLooper.mQueue;
  mCallback = callback;
  mAsynchronous = async;
 }

我们平常用的是无参数的方法,它传入的是空的回调以及false。

 public static @Nullable Looper myLooper() {
  return sThreadLocal.get();
 }

这里就出现了我们之前说的ThreadLoacal类,那么looper值是什么时候设置进去的呢?

它的设置方法其实是在prepare方法以及prepareMainLooper方法中,我们来分别来看下:

 public static void prepare() {
  prepare(true);
 }

 private static void prepare(boolean quitAllowed) {
  // 在创建looper之前,判断looper是否与threadloacal绑定过,这也是prepare只能设置一遍的原因。
  if (sThreadLocal.get() != null) {
   throw new RuntimeException("Only one Looper may be created per thread");
  }
  sThreadLocal.set(new Looper(quitAllowed));
 }

 public static void prepareMainLooper() {
  // 这里其实还是调用的prepare方法
  prepare(false);
  synchronized (Looper.class) {
   if (sMainLooper != null) {
    throw new IllegalStateException("The main Looper has already been prepared.");
   }
   sMainLooper = myLooper();
  }
 }

通过上面可以prepare方法只能设置一遍,那么我们在主线程中为什么能直接使用呢? app程序的入口是在ActivityThread中的main方法中:

public static void main(String[] args) {
  ...

  //1. 初始化Looper对象
  Looper.prepareMainLooper();

  // 2. 开启无限循环
  Looper.loop();
  throw new RuntimeException("Main thread loop unexpectedly exited");
 }

看到了吧,初始化在这里,那么我们再来看下looper的初始化方法:

 private Looper(boolean quitAllowed) {
  mQueue = new MessageQueue(quitAllowed);
  mThread = Thread.currentThread();
 }

Looper的初始化做了两件事:创建消息队列MessageQueue以及获取当前的线程。 到这里,我们可以得到一个结论:

  • prepare方法在一个线程中只能调用一次。
  • Looper的初始化在一个线程中只能调用一次。
  • 最后可以得知:一个线程对应一个Looper,一个Looper对应一个MessageQueue。

Looper可以理解为一个工厂线,不断从MessageQueue中取Message,工厂线开启的方式就是Looper.loop()

 public static void loop() {
  final Looper me = myLooper();
  // 1. 判断looper是否存在
  if (me == null) {
   throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
  }
  final MessageQueue queue = me.mQueue;
  ...

  //2. 开启一个死循环
  for (;;) {
   Message msg = queue.next(); // might block
   if (msg == null) {
    // No message indicates that the message queue is quitting.
    return;
   }
   ...
   try {
    msg.target.dispatchMessage(msg);
    dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
   } finally {
    if (traceTag != 0) {
     Trace.traceEnd(traceTag);
    }
   }
  ...
  }
 }

looper方法通过开启一个死循环,不断从MessageQueue中取Message消息,当message为空时,退出该循环,否则调用msg.target.dispatchMessage(msg)方法,target就是msg绑定的Handler对象。

Handler的工作原理

好了到这里又回到了Handler类中。

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

这个handleMessage就是我们需要实现的方法。 那么Handler是如何设置到Message中的呢?我们来看下我们熟知的sendMessage方法:

 public final boolean sendMessage(Message msg)
 {
  return sendMessageDelayed(msg, 0);
 }

 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;
  ...
  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);
 }

可以看到,通过一系列的方法,在enqueueMessage中将handler赋值到msg的target中。最后调用的是MessageQueue的enqueueMessage方法中:

 boolean enqueueMessage(Message msg, long when) {
  if (msg.target == null) {
   throw new IllegalArgumentException("Message must have a target.");
  }
  if (msg.isInUse()) {
   throw new IllegalStateException(msg + " This message is already in use.");
  }

  synchronized (this) {
   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;
   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 {
    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; // invariant: p == prev.next
    prev.next = msg;
   }

   // We can assume mPtr != 0 because mQuitting is false.
   if (needWake) {
    nativeWake(mPtr);
   }
  }
  return true;
 }

enqueueMessage方法主要做了两件事:

首先判断handler是否存在以及是否在使用中。然后根据时间顺序插入MessageQueue中。

到这里基本的流程已经梳理完了,回到起初我们的问题:Looper.loop()是一个死循环,为什么不会堵塞主线程呢?

我们来看下MessageQueue的next方法:

 Message next() {
  final long ptr = mPtr;
  if (ptr == 0) {
   return null;
  }

  int pendingIdleHandlerCount = -1; // -1 only during first iteration
  int nextPollTimeoutMillis = 0;
  for (;;) {

   nativePollOnce(ptr, nextPollTimeoutMillis);
   ...
  }
 }

nativePollOnce方法是一个 native 方法,当调用此 native 方法时,主线程会释放 CPU 资源进入休眠状态,直到下条消息到达或者有事务发生,通过往 pipe 管道写端写入数据来唤醒主线程工作,这里采用的 epoll 机制。关于 nativePollOnce 的详细分析可以参考:nativePollOnce函数分析

总结

  1. app程序启动从ActivityThread中的main方法中开始,通过Looper.prepare()进行Looper以及MessageQueue的创建以及ThreadLocal与线程之间的绑定。
  2. 我们在创建Handler时,通过ThreadLocal来获取该线程中的Looper以及在Looper上绑定的MessageQueue。
  3. 通过Handler.sendMessage()方法来将msg与Handler之间进行绑定,然后将msg通过时间顺序插入MessageQueue中。
  4. 主线程创建后,Looper.loop()来启动一个(不占用资源)死循环,从Looper已经存在的MessageQueue中不断取出Message,然后调用不为空的Message绑定的Handler的dispatchMessage(msg)方法,最后会调用我们复写的handlerMessage方法中。

参考资料

Androi开发艺术探索

以上就是从源码角度分析Android的消息机制的详细内容,更多关于Android 消息机制的资料请关注我们其它相关文章!

时间: 2021-03-26

Android异步消息机制详解

Android中的异步消息机制分为四个部分:Message.Handler.MessageQueue和Looper. 其中,Message是线程之间传递的消息,其what.arg1.arg2字段可以携带整型数据,obj字段可以携带一个Object对象. Handler是处理者,主要用于发送消息和处理消息.发送消息的方法是sendMessage:处理消息的方法是handleMessage(),Message字段携带的信息在该方法中用作判别. MessageQueue是消息队列,存放所有Handle

android利用消息机制获取网络图片

在前面都写到用AsyncTask来获取网络中的图片.其实利用消息机制也能获取网络中的图片,而且本人感觉用消息机制还是挺简单的. 消息机制的图解: 下面就用看代码来理解上面的图片. 布局:activity_main.xml <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" an

android异步消息机制 源码层面彻底解析(1)

Handler.Message.Loopler.MessageQueen 首先看一下我们平常使用Handler的一个最常见用法. Handler handler =new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage(msg); //这里进行一些UI操作等处理 } new Thread(new Runnable() { @Override public void run() {

代码分析Android消息机制

我们知道在编程时许多操作(如更新UI)需要在主线程中完成,而且,耗时操作(如网络连接)需要放在子线程中,否则会引起ANR.所以我们常使用Handler来实现线程间的消息传递,这里讨论的也就是Handler的运行机制. Handler的运行主要由两个类来支撑:Looper与MessageQueue.熟悉开发的朋友都知道在子线程中默认是无法创建Handler的,这是因为子线程中不存在消息队列.当需要创建一个与子线程绑定的Handler时,标准代码如下: class LooperThread exte

Android 消息机制详解及实例代码

Android 消息机制 1.概述 Android应用启动时,会默认有一个主线程(UI线程),在这个线程中会关联一个消息队列(MessageQueue),所有的操作都会被封装成消息队列然后交给主线程处理.为了保证主线程不会退出,会将消息队列的操作放在一个死循环中,程序就相当于一直执行死循环,每循环一次,从其内部的消息队列中取出一个消息,然后回调相应的消息处理函数(handlerMessage),执行完成一个消息后则继续循环,若消息队列为空,线程则会阻塞等待.因此不会退出.如下图所示: Handl

android异步消息机制 从源码层面解析(2)

AsyncTask 什么是AsyncTask AsyncTask是一个轻量级的异步任务类,它可以在线程池中执行后台任务,然后把执行的进度和结果传递给主线程并在主线程中更新UI. AsyncTask这个类的声明如下 public abstract class AsyncTask<Params, Progress, Result> 它提供了Params, Progress和 Result三个泛型参数,在下面会仔细分析这三个泛型参数的具体含义. AsyncTask提供了四个核心方法 onPreExe

Android消息机制Handler的工作过程详解

综述 在Android系统中,出于对性能优化的考虑,对于Android的UI操作并不是线程安全的.也就是说若是有多个线程来操作UI组件,就会有可能导致线程安全问题.所以在Android中规定只能在UI线程中对UI进行操作.这个UI线程是在应用第一次启动时开启的,也称之为主线程(Main Thread),该线程专门用来操作UI组件,在这个UI线程中我们不能进行耗时操作,否则就会出现ANR(Application Not Responding)现象.如果我们在子线程中去操作UI,那么程序就回给我们抛

android线程消息机制之Handler详解

android线程消息机制主要由Handler,Looper,Message和MessageQuene四个部分组成.平常在开发中,我们常用来在子线程中通知主线程来更新,其实整个安卓生命周期的驱动都是通过Handler(ActivityThread.H)来实现的. 首先我们先介绍这四个类的作用: Handler:消息的发送者.负责将Message消息发送到MessageQueue中.以及通过Runnable,Callback或者handleMessage()来实现消息的回调处理 Looper:是消

深入剖析Android消息机制原理

在Android中,线程内部或者线程之间进行信息交互时经常会使用消息,这些基础的东西如果我们熟悉其内部的原理,将会使我们容易.更好地架构系统,避免一些低级的错误.在学习Android中消息机制之前,我们先了解与消息有关的几个类: 1.Message 消息对象,顾名思义就是记录消息信息的类.这个类有几个比较重要的字段: a.arg1和arg2:我们可以使用两个字段用来存放我们需要传递的整型值,在Service中,我们可以用来存放Service的ID. b.obj:该字段是Object类型,我们可以

Android 消息机制以及handler的内存泄露

Handler 每个初学Android开发的都绕不开Handler这个"坎",为什么说是个坎呢,首先这是Android架构的精髓之一,其次大部分人都是知其然却不知其所以然.今天看到Handler.post这个方法之后决定再去翻翻源代码梳理一下Handler的实现机制. 异步更新UI 先来一个必背口诀"主线程不做耗时操作,子线程不更新UI",这个规定应该是初学必知的,那要怎么来解决口诀里的问题呢,这时候Handler就出现在我们面前了(AsyncTask也行,不过本质

Android的消息机制

一.简介 Android的消息机制主要是指Handler的运行机制,那么什么是Handler的运行机制那?通俗的来讲就是,使用Handler将子线程的Message放入主线程的Messagequeue中,在主线程使用. 二.学习内容 学习Android的消息机制,我们需要先了解如下内容. 消息的表示:Message 消息队列:MessageQueue 消息循环,用于循环取出消息进行处理:Looper 消息处理,消息循环从消息队列中取出消息后要对消息进行处理:Handler 平常我们接触的大多是H

Android 消息机制问题总结

Android的消息机制几乎是面试必问的话题,当然也并不是因为面试,而去学习,更重要的是它在Android的开发中是必不可少的,占着举足轻重的地位,所以弄懂它是很有必要的.下面就来说说最基本的东西. Looper 作用: 关联起Thread 循环取出消息 1.Looper是否可以直接实例化? Looper构造方法是私有的,其中做了两件事 创建一个MessageQueue 得到与之对应的Thread private Looper(boolean quitAllowed) { mQueue = ne