Android Handler 消息机制原理解析
前言
做过 Android 开发的童鞋都知道,不能在非主线程修改 UI 控件,因为 Android 规定只能在主线程中访问 UI ,如果在子线程中访问 UI ,那么程序就会抛出异常
android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy .
并且,Android 也不建议在 UI 线程既主线程中做一些耗时操作,否则会导致程序 ANR 。如果我们需要做一些耗时的操作并且操作结束后要修改 UI ,那么就需要用到 Android 提供的 Handler 切换到主线程来访问 UI 。因此,系统之所以提供 Handler,主要原因就是为了解决在子线程中无法访问 UI 的问题。
概述
要理解 Handler 消息机制原理 还需要了解几个概念:
UI 线程
主线程 ActivityThread
Message
Handler 发送和处理的消息,由 MessageQueue 管理。
MessageQueue
消息队列,用来存放通过 Handler 发送的消息,按照先进先出执行,内部使用的是单链表的结构。
Handler
负责发送消息和处理消息。
Looper
负责消息循环,循环取出 MessageQueue 里面的 Message,并交给相应的 Handler 进行处理。
在应用启动时,会开启一个 UI 线程,并且启动消息循环,应用不停地从该消息列表中取出、处理消息达到程序运行的效果。
Looper 负责的就是创建一个 MessageQueue,然后进入一个无限循环体不断从该 MessageQueue 中读取消息,而消息的创建者就是一个或多个 Handler 。
流程图如下:
下面结合源码来具体分析
Looper
Looper 比较重要的两个方法是 prepare( ) 和 loop( )
先看下构造方法
final MessageQueue mQueue;
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
Looper 在创建时会新建一个 MessageQueue
通过 prepare 方法可以为 Handler 创建一个 Lopper,源码如下:
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper; // guarded by Looper.class
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
//一个线程只能有一个looper
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
可以看到这里创建的 Looper 对象使用 ThreadLocal 保存,这里简单介绍下 ThreadLocal。
ThreadLocal 是一个线程内部的数据存储类,通过它可以在指定的线程中存储数据,数据存储以后,只有在指定线程中可以获取到存储的数据,对于其他线程来说则无法获取到数据,这样就保证了一个线程对应了一个 Looper,从源码中也可以看出一个线程也只能有一个 Looper
,否则就会抛出异常。
prepareMainLooper() 方法是 系统在 ActivityThread 中调用的。
ActivityThread.java
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
SamplingProfilerIntegration.start();
//...省略代码
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
由此可以看出,系统在创建时,会自动创建 Looper 来处理消息,所以我们一般在主线程中使用 Handler 时,是不需要手动调用 Looper.prepare() 的。这样 Handler 就默认和主线程的 Looper 绑定。
当 Handler 绑定的 Looper 是主线程的 Looper 时,则该 Handler 可以在其 handleMessage 中更新UI,否则更新 UI 则会抛出异常。
在开发中,我们可能在多个地方使用 Handler,所以又可以得出一个结论:一个 Looper 可以和多个 Handler 绑定
,那么 Looper 是怎么区分 Message 由哪个 Handler 处理呢?
继续看源码 loop()
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (slowDispatchThresholdMs > 0) {
final long time = end - start;
if (time > slowDispatchThresholdMs) {
Slog.w(TAG, "Dispatch took " + time + "ms on "
+ Thread.currentThread().getName() + ", h=" +
msg.target + " cb=" + msg.callback + " msg=" + msg.what);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycleUnchecked();// 回收消息
}
}
代码比较多,我们捡重点看。
2~6 行 获取当前 Looper 如果没有则抛异常,有则获取消息队列 MessageQueue
所以如果我们在子线程中使用 Handler 则必须手动调用 Looper.prepare() 和 Looper.loop()
系统在代码中提供了示例代码
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
Looper.loop();
}
}
获取到 MessageQueue 后开启消息循环,不断从 MessageQueue 中取消息,无则阻塞,等待消息。有则调用 msg.target.dispatchMessage(msg) 处理消息。
msg.target 就是 Message 所属的 Handler,这个会再后面具体介绍 Handler 中会说明
所以上面的问题就可以回答了,Looper 不需要考虑怎么区分 Message 由哪个 Handler 处理,只负责开启消息循环接收消息并处理消息即可。处理完消息后会调用 msg.recycleUnchecked() 来回收消息。
那么开启消息循环后,可以停止吗?
答案是肯定的,Looper 提供了 quit() 和 quitSafely() 来退出。
public void quit() {
mQueue.quit(false);
}
public void quitSafely() {
mQueue.quit(true);
}
可以看到实际上调用的是 MessageQueue 中的退出方法,具体会在 MessageQueue 中介绍。
调用 quit()
会直接退出 Looper,而 quitSafely() 只是设定一个退出标记,然后把消息队列中的已有消息处理完毕后才安全地退出。在
Loooper 退出后,通过 Handler 发送消息会失败。如果在子线程中手动创建了 Looper ,则应在处理完操作后退出 Looper
终止消息循环。
到此 Looper 的源码分析就完了,我们来总结下 Looper 所做的工作:
- 被创建时与线程绑定,保证一个线程只会有一个 Looper 实例 ,并且一个 Looper 实例只有一个 MessageQueue
- 创建后,调用 loop( ) 开启消息循环,不断从 MessageQueue 中取 Message ,然后交给 Message 所属的 Handler 去处理,也就是 msg.target 属性。
- 处理完消息后,调用 msg.recycleUnchecked 来回收消息
Message 和 MessageQueue
Message 是线程通信中传递的消息,它有几个关键点
- 使用 what 来区分消息
- 使用 arg1、arg2、obj、data 来传递数据
- 参数 target,它决定了 Message 所关联的 Handler,这个在后面看 Handler 源码时会一目了然。
MessageQueue
MessageQueue 负责管理消息队列,通过一个单链表的数据结构来维护。
源码中有三个主要方法:
- enqueueMessage 方法往消息列表中插入一条数据,
- next 方法从消息队列中取出一条消息并将其从消息队列中移除
- quit 方法退出消息列表,通过参数 safe 决定是否直接退出
next 方法
Message next() {
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
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 {
// No more messages.
nextPollTimeoutMillis = -1;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
//...省略代码
}
}
可以发现 next 方法是一个无限循环的方法,如果消息队列中没有消息,那么 next 方法会一直阻塞在这里。当有新消息到来时,next 方法会从中获取消息出来返回给 Looper 去处理,并将其从消息列表中移除。
quit方法
void quit(boolean safe) {
if (!mQuitAllowed) {
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
if (mQuitting) {
return;
}
mQuitting = true;
if (safe) {
removeAllFutureMessagesLocked();//移除尚未处理的消息
} else {
removeAllMessagesLocked();//移除所有消息
}
// We can assume mPtr != 0 because mQuitting was previously false.
nativeWake(mPtr);
}
}
private void removeAllMessagesLocked() {
Message p = mMessages;
while (p != null) {
Message n = p.next;
p.recycleUnchecked();
p = n;
}
mMessages = null;
}
private void removeAllFutureMessagesLocked() {
final long now = SystemClock.uptimeMillis();
Message p = mMessages;
if (p != null) {
if (p.when > now) {
removeAllMessagesLocked(); // 移除尚未处理的消息
} else { // 正在处理的消息不做处理
Message n;
for (;;) {
n = p.next;
if (n == null) {
return;
}
if (n.when > now) {
break;
}
p = n;
}
p.next = null;
do {
p = n;
n = p.next;
p.recycleUnchecked();
} while (n != null);
}
}
}
从 上述代码中可以看出,当 safe 为 true 时,只移除尚未触发的所有消息,对于正在处理的消息不做处理,当 safe 为 false 时,移除所有消息。
Handler
Handler 是我们使用最多的类,主要用来发送消息和处理消息。
先来看构造方法
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
//获取当前线程的 Looper 实例,如果不存在则抛出异常
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//关联 Looper 中的 MessageQueue 消息队列
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
构造方法主要有三个参数
- looper 不传值则调用 Looper.myLooper( ) 获取当前线程的 Looper 实例;传值则使用,一般是在子线程中使用 Handler 时才传参数。
- callback Handler 处理消息时的回调
- async 是否是异步消息。这里和 Android 中的 Barrier 概念有关,当 View 在绘制和布局时会向 Looper 中添加了 Barrier(监控器),这样后续的消息队列中的同步的消息将不会被执行,以免会影响到 UI绘制,但是只有异步消息才能被执行。所谓的异步消息也只是体现在这,async 为 true 时,消息还可以继续被执行,不会被推迟运行。
从源码中可看出,因为 UI 线程在启动时会自动创建 Looper 实例,所以一般我们在 UI 线程中使用 Handler 时不需要传递 Looper 对象。而在子线程中则必须手动调用 Looper.prepare 和 Looper.loop 方法,并传递给 Handler ,否则无法使用,这一点肯定有不少童鞋都遇到过。
在拿到 Looper 对象后,Handler 会获取 Looper 中的 MessageQueue 消息队列,这样就和 MessageQueue 关联上了。
关联上 MessageQueue ,接下来那我们就看下 Handler 是如何发送消息的。
Handler 发送消息方法很多,实际上最后都是调用的 enqueueMessage 方法,看图说话
主要看 enqueueMessage 方法
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);
}
可以看到在发送消息时给 Message 设置了 target = this 也就是当前的 Handler 对象,并调用了 MessageQueue 的 enqueueMessage 方法,这样就把消息存在消息队列,然后由 Looper 处理了。
童鞋们应该记得之前在讲 Looper 时,说到 Looper 开启消息循环后,会不断从 MessageQueue 中取出Message,并调用 msg.target.dispatchMessage(msg) 来处理消息。
接下来,就来看看 Handler 是如何接收消息的也就是 dispatchMessage 方法
public interface Callback {
public boolean handleMessage(Message msg);
}
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
可以看出 Handler 接收消息,只是调用一个空方法 handleMessage 是不是有些眼熟呢,看下我们写过很多次的 Handler 代码
private Handler mHandler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
case value:
break;
default:
break;
}
}
};
没错这就是我们自己创建 Handler 时重写的方法,由我们来处理消息,然后根据 msg.what 标识进行消息处理。
总结
应用启动时会启动 UI 线程也就是主线程 ActivityThread,在 ActivityThread 的 main 方法中会调用 Looper.prepareMainLooper( ) 和 Looper.loop ( ) 启动 Looper 。
Looper 启动时会创建一个 MessageQueue 实例,并且只有一个实例,然后不断从 MessageQueue 中获取消息,无则阻塞等待消息,有则调用 msg.target.dispatchMessage(msg) 处理消息。
我们在使用
Handler 时 需要先创建 Handler 实例,Handler 在创建时会获取当前线程关联的 Looper 实例 ,和 Looper
中的消息队列 MessageQueue。然后在发送消息时会自动给 Message 设置 target 为 Handler 本身,并把消息放入
MessageQueue 中,由 Looper 处理。Handler 在创建时会重写的
handleMessage 方法中处理消息。
如果要在子线程中使用 Handler 就需要新建 Looper 实例,传给 Handler 即可。
Android Handler 消息机制原理解析的更多相关文章
- Android Handler消息机制不完全解析
1.Handler的作用 Android开发中,我们经常使用Handler进行页面的更新.例如我们需要在一个下载任务完成后,去更新我们的UI效果,因为AndroidUI操作不是线程安全的,也就意味着我 ...
- Android Handler消息机制源码解析
好记性不如烂笔头,今天来分析一下Handler的源码实现 Handler机制是Android系统的基础,是多线程之间切换的基础.下面我们分析一下Handler的源码实现. Handler消息机制有4个 ...
- Android Handler消息机制深入浅出
尊重原创:http://blog.csdn.net/yuanzeyao/article/details/38408493 作为Android开发者,Handler这个类应该是再熟悉只是了.由于差点儿不 ...
- 深入理解 Android 消息机制原理
欢迎大家前往腾讯云社区,获取更多腾讯海量技术实践干货哦~ 作者:汪毅雄 导语: 本文讲述的是Android的消息机制原理,从Java到Native代码进行了梳理,并结合其中使用到的Epoll模型予以介 ...
- Handler消息机制的一些原理(直接用code讲解)——Android开发
package com.example.handlertest; import android.os.Bundle; import android.os.Handler; import android ...
- Android全面解析之由浅及深Handler消息机制
前言 很高兴遇见你~ 欢迎阅读我的文章. 关于Handler的博客可谓是俯拾皆是,而这也是一个老生常谈的话题,可见的他非常基础,也非常重要.但很多的博客,却很少有从入门开始介绍,这在我一开始学习的时候 ...
- Android消息传递之Handler消息机制
前言: 无论是现在所做的项目还是以前的项目中,都会遇见线程之间通信.组件之间通信,目前统一采用EventBus来做处理,在总结学习EventBus之前,觉得还是需要学习总结一下最初的实现方式,也算是不 ...
- Handler消息机制与Binder IPC机制完全解析
1.Handler消息机制 序列 文章 0 Android消息机制-Handler(framework篇) 1 Android消息机制-Handler(native篇) 2 Android消息机制-H ...
- 【原创】源码角度分析Android的消息机制系列(五)——Looper的工作原理
ι 版权声明:本文为博主原创文章,未经博主允许不得转载. Looper在Android的消息机制中就是用来进行消息循环的.它会不停地循环,去MessageQueue中查看是否有新消息,如果有消息就立刻 ...
随机推荐
- SpringBoot教程(学习资源)
SpringBoot教程 SpringBoot–从零开始学SpringBoot SpringBoot教程1 SpringBoot教程2 --SpringBoot教程2的GitHub地址 SpringB ...
- Redis去重方法
目录 1.基于 set 2.基于 bit 3.基于 HyperLogLog 4. 基于bloomfilter 这篇文章主要介绍了Redis实现唯一计数的3种方法分享,本文讲解了基于SET.基于 bit ...
- Go 跳出 for-switch 和 for-select 代码块
原文:https://segmentfault.com/a/1190000013739000 没有指定标签的 break 只会跳出 switch/select 语句,若不能使用 return 语句跳出 ...
- 一.Promise入门准备阶段
一.Promise入门准备阶段 1.区别实例对象呵函数对象 2.两种类型的回调函数(同步与异步) 2.1 同步回调 2.2 异步回调 3.JS的error处理 3.1 错误的类型 3.2 错误处理与错 ...
- 用 Node.js 实现的最简单的 HTTP 服务器
用 Node.js 实现的最简单的 HTTP 服务器 //app.js var http = require('http'); http.createServer(function(req, res) ...
- Vue中computed计算属性
话不多说,使用方法直接上代码//在模板中调用computedTest这个函数,切记不要在函数后添加()<template> <div class="home"&g ...
- 问题 K: 找点
题目描述 上数学课时,老师给了LYH一些闭区间,让他取尽量少的点,使得每个闭区间内至少有一个点.但是这几天LYH太忙了,你们帮帮他吗? 输入 多组测试数据. 每组数据先输入一个N,表示有N个闭区间(N ...
- python递归三战:Sierpinski Triangle、Tower of Hanoi、Maze Exploring
本文已做成视频教程投稿b站(视频版相对文本版有一些改进),点击观看视频教程 本文主要通过三个实例来帮助大家理解递归(其展示动画已上传B站): 谢尔宾斯基三角形(Sierpinski Triangle) ...
- CSS学习笔记:flex布局
目录 一.Flex布局简介 1. Flex布局的主要作用 2. Flex布局应用场景 二.Flex布局的使用 1. Flex布局的两种相关元素 2. 父项属性 2.1 flex- direction ...
- ECharts 点击事件
一个问题 ECharts 点击出现多个弹窗