Android异步消息机制
2019独角兽企业重金招聘Python工程师标准>>>
目录介绍
- 1.Handler的常见的使用方式
- 2.如何在子线程中定义Handler
- 3.主线程如何自动调用Looper.prepare()
- 4.Looper.prepare()方法源码分析
- 5.Looper中用什么存储消息
- 6.Handler发送消息如何运作
- 7.Looper.loop()方法源码分析
- 8.runOnUiThread如何实现子线程更新UI
- 9.Handler的post方法和view的post方法
- 10.得出部分结论
好消息
- 博客笔记大汇总【16年3月到至今】,包括Java基础及深入知识点,Android技术博客,Python学习笔记等等,还包括平时开发中遇到的bug汇总,当然也在工作之余收集了大量的面试题,长期更新维护并且修正,持续完善……开源的文件是markdown格式的!同时也开源了生活博客,从12年起,积累共计47篇[近20万字],转载请注明出处,谢谢!
- 链接地址:https://github.com/yangchong211/YCBlogs
- 如果觉得好,可以star一下,谢谢!当然也欢迎提出建议,万事起于忽微,量变引起质变!
- 00.Android异步消息机制
- 如何在子线程中定义Handler,主线程如何自动调用Looper.prepare(),Looper.prepare()方法源码分析,Looper中用什么存储消息,Looper.loop()方法源码分析,runOnUiThread如何实现子线程更新UI等等
- 01.Handler消息机制
- 为什么不允许在子线程中访问UI,Handler消息机制作用,避免子线程手动创建looper,ActivityThread源码分析,ActivityThread源码分析,Looper死循环为什么不会导致应用卡死,会消耗大量资源吗?
1.Handler的常见的使用方式
- handler机制大家都比较熟悉呢。在子线程中发送消息,主线程接受到消息并且处理逻辑。如下所示
- 一般handler的使用方式都是在主线程中定义Handler,然后在子线程中调用mHandler.sendXx()方法,这里有一个疑问可以在子线程中定义Handler吗?
public class MainActivity extends AppCompatActivity {private TextView tv ;/*** 在主线程中定义Handler,并实现对应的handleMessage方法*/public static Handler mHandler = new Handler() {@Overridepublic void handleMessage(Message msg) {if (msg.what == 101) {Log.i("MainActivity", "接收到handler消息...");}}};@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);tv = (TextView) findViewById(R.id.tv);tv.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {new Thread() {@Overridepublic void run() {// 在子线程中发送异步消息mHandler.sendEmptyMessage(1);}}.start();}});} }
2.如何在子线程中定义Handler
- 直接在子线程中创建handler,看看会出现什么情况?
- 运行后可以得出在子线程中定义Handler对象出错,难道Handler对象的定义或者是初始化只能在主线程中?其实不是这样的,错误信息中提示的已经很明显了,在初始化Handler对象之前需要调用Looper.prepare()方法
tv.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {new Thread() {@Overridepublic void run() {Handler mHandler = new Handler() {@Overridepublic void handleMessage(Message msg) {if (msg.what == 1) {Log.i(TAG, "在子线程中定义Handler,接收并处理消息");}}};}}.start();} });
- 如何正确运行。在这里问一个问题,在子线程中可以吐司吗?答案是可以的,只不过又条件,详细可以看这篇文章02.Toast源码深度分析
- 这样程序已经不会报错,那么这说明初始化Handler对象的时候我们是需要调用Looper.prepare()的,那么主线程中为什么可以直接初始化Handler呢?难道是主线程创建handler对象的时候,会自动调用Looper.prepare()方法的吗?
tv.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {new Thread() {@Overridepublic void run() {Looper.prepare();Handler mHandler = new Handler() {@Overridepublic void handleMessage(Message msg) {if (msg.what == 1) {Log.i(TAG, "在子线程中定义Handler,接收并处理消息");}}};Looper.loop();}}.start();} });
3.主线程如何自动调用Looper.prepare()
- 首先直接可以看在App初始化的时候会执行ActivityThread的main方法中的代码,如下所示
- 可以看到Looper.prepare()方法在这里调用,所以在主线程中可以直接初始化Handler了。
public static void main(String[] args) {//省略部分代码Looper.prepareMainLooper();ActivityThread thread = new ActivityThread();thread.attach(false);if (sMainThreadHandler == null) {sMainThreadHandler = thread.getHandler();}if (false) {Looper.myLooper().setMessageLogging(newLogPrinter(Log.DEBUG, "ActivityThread"));}Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);Looper.loop();throw new RuntimeException("Main thread loop unexpectedly exited"); }
- 并且可以看到还调用了:Looper.loop()方法,可以知道一个Handler的标准写法其实是这样的
Looper.prepare(); Handler mHandler = new Handler() {@Overridepublic void handleMessage(Message msg) {if (msg.what == 101) {Log.i(TAG, "在子线程中定义Handler,并接收到消息");}} }; Looper.loop();
4.Looper.prepare()方法源码分析
- 源码如下所示
- 可以看到Looper中有一个ThreadLocal成员变量,熟悉JDK的同学应该知道,当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每一个线程都可以独立地改变自己的副本,而不会影响其它线程所对应的副本。
public static void prepare() {prepare(true); }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)); }
- 思考:Looper.prepare()能否调用两次或者多次
- 如果运行,则会报错,并提示prepare中的Excetion信息。由此可以得出在每个线程中Looper.prepare()能且只能调用一次
//这里Looper.prepare()方法调用了两次 Looper.prepare(); Looper.prepare(); Handler mHandler = new Handler() {@Overridepublic void handleMessage(Message msg) {if (msg.what == 1) {Log.i(TAG, "在子线程中定义Handler,并接收到消息。。。");}} }; Looper.loop();
5.Looper中用什么存储消息
- 先看一下下面得源代码
- 看Looper对象的构造方法,可以看到在其构造方法中初始化了一个MessageQueue对象。MessageQueue也称之为消息队列,特点是先进先出,底层实现是单链表数据结构
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)); }private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);mThread = Thread.currentThread(); }
- 得出结论
- Looper.prepare()方法初始话了一个Looper对象并关联在一个MessageQueue对象,并且一个线程中只有一个Looper对象,只有一个MessageQueue对象。
6.Handler发送消息如何运作
- 首先看看构造方法
- 可以看出在Handler的构造方法中,主要初始化了一下变量,并判断Handler对象的初始化不应再内部类,静态类,匿名类中,并且保存了当前线程中的Looper对象。
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());}}mLooper = Looper.myLooper();if (mLooper == null) {throw new RuntimeException("Can't create handler inside thread that has not called Looper.prepare()");}mQueue = mLooper.mQueue;mCallback = callback;mAsynchronous = async; }
- 看handler.sendMessage(msg)方法
- 关于下面得源码,是步步追踪,看enqueueMessage这个方法,原来msg.target就是Handler对象本身;而这里的queue对象就是我们的Handler内部维护的Looper对象关联的MessageQueue对象。
handler.sendMessage(message);//追踪到这一步 public final boolean sendMessage(Message msg){return sendMessageDelayed(msg, 0); }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); }
- 看MessageQueue对象的enqueueMessage方法
- 看到这里MessageQueue并没有使用列表将所有的Message保存起来,而是使用Message.next保存下一个Message,从而按照时间将所有的Message排序
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 {// Inserted within the middle of the queue. Usually we don't have to wake// up the event queue unless there is a barrier at the head of the queue// and the message is the earliest asynchronous message in the queue.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.nextprev.next = msg;}// We can assume mPtr != 0 because mQuitting is false.if (needWake) {nativeWake(mPtr);}}return true; }
7.Looper.loop()方法源码分析
- 看看里面得源码,如下所示
- 看到Looper.loop()方法里起了一个死循环,不断的判断MessageQueue中的消息是否为空,如果为空则直接return掉,然后执行queue.next()方法
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;Binder.clearCallingIdentity();final long ident = Binder.clearCallingIdentity();for (;;) {Message msg = queue.next(); // might blockif (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 loggerfinal 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();} }
- 看queue.next()方法源码
- 大概的实现逻辑就是Message的出栈操作,里面可能对线程,并发控制做了一些限制等。获取到栈顶的Message对象之后开始执行:msg.target.dispatchMessage(msg)
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 iterationint 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;}// If first time idle, then get the number of idlers to run.// Idle handles only run if the queue is empty or if the first message// in the queue (possibly a barrier) is due to be handled in the future.if (pendingIdleHandlerCount < 0&& (mMessages == null || now < mMessages.when)) {pendingIdleHandlerCount = mIdleHandlers.size();}if (pendingIdleHandlerCount <= 0) {// No idle handlers to run. Loop and wait some more.mBlocked = true;continue;}if (mPendingIdleHandlers == null) {mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];}mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);}// Run the idle handlers.// We only ever reach this code block during the first iteration.for (int i = 0; i < pendingIdleHandlerCount; i++) {final IdleHandler idler = mPendingIdleHandlers[i];mPendingIdleHandlers[i] = null; // release the reference to the handlerboolean keep = false;try {keep = idler.queueIdle();} catch (Throwable t) {Log.wtf(TAG, "IdleHandler threw exception", t);}if (!keep) {synchronized (this) {mIdleHandlers.remove(idler);}}}// Reset the idle handler count to 0 so we do not run them again.pendingIdleHandlerCount = 0;// While calling an idle handler, a new message could have been delivered// so go back and look again for a pending message without waiting.nextPollTimeoutMillis = 0;} }
- 那么msg.target是什么呢?通过追踪可以知道就是定义的Handler对象,然后查看一下Handler类的dispatchMessage方法:
- 可以看到,如果我们设置了callback(Runnable对象)的话,则会直接调用handleCallback方法
- 在初始化Handler的时候设置了callback(Runnable)对象,则直接调用run方法。
public void dispatchMessage(Message msg) {if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}handleMessage(msg);} }private static void handleCallback(Message message) {message.callback.run(); }
8.runOnUiThread如何实现子线程更新UI
- 看看源码,如下所示
- 如果msg.callback为空的话,会直接调用我们的mCallback.handleMessage(msg),即handler的handlerMessage方法。由于Handler对象是在主线程中创建的,所以handler的handlerMessage方法的执行也会在主线程中。
- 在runOnUiThread程序首先会判断当前线程是否是UI线程,如果是就直接运行,如果不是则post,这时其实质还是使用的Handler机制来处理线程与UI通讯。
public void dispatchMessage(Message msg) {if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}handleMessage(msg);} }@Override public final void runOnUiThread(Runnable action) {if (Thread.currentThread() != mUiThread) {mHandler.post(action);} else {action.run();} }
9.Handler的post方法和view的post方法
- Handler的post方法实现很简单,如下所示
mHandler.post(new Runnable() {@Overridepublic void run() {} });public final boolean post(Runnable r){return sendMessageDelayed(getPostMessage(r), 0); }
- view的post方法也很简单,如下所示
- 可以发现其调用的就是activity中默认保存的handler对象的post方法
public boolean post(Runnable action) {final AttachInfo attachInfo = mAttachInfo;if (attachInfo != null) {return attachInfo.mHandler.post(action);}ViewRootImpl.getRunQueue().post(action);return true; }public void post(Runnable action) {postDelayed(action, 0); }public void postDelayed(Runnable action, long delayMillis) {final HandlerAction handlerAction = new HandlerAction(action, delayMillis);synchronized (this) {if (mActions == null) {mActions = new HandlerAction[4];}mActions = GrowingArrayUtils.append(mActions, mCount, handlerAction);mCount++;} }
10.得出部分结论
- 得出得结论如下所示
- 1.主线程中定义Handler对象,ActivityThread的main方法中会自动创建一个looper,并且与其绑定。如果是子线程中直接创建handler对象,则需要手动创建looper。不过手动创建不太友好,需要手动调用quit方法结束looper。这个后面再说
- 2.一个线程中只存在一个Looper对象,只存在一个MessageQueue对象,可以存在N个Handler对象,Handler对象内部关联了本线程中唯一的Looper对象,Looper对象内部关联着唯一的一个MessageQueue对象。
- 3.MessageQueue消息队列不是通过列表保存消息(Message)列表的,而是通过Message对象的next属性关联下一个Message从而实现列表的功能,同时所有的消息都是按时间排序的。
关于其他内容介绍
01.关于博客汇总链接
- 1.技术博客汇总
- 2.开源项目汇总
- 3.生活博客汇总
- 4.喜马拉雅音频汇总
- 5.其他汇总
02.关于我的博客
- 我的个人站点:www.yczbj.org,www.ycbjie.cn
- github:https://github.com/yangchong211
- 知乎:https://www.zhihu.com/people/yang-chong-69-24/pins/posts
- 简书:http://www.jianshu.com/u/b7b2c6ed9284
- csdn:http://my.csdn.net/m0_37700275
- 喜马拉雅听书:http://www.ximalaya.com/zhubo/71989305/
- 开源中国:https://my.oschina.net/zbj1618/blog
- 泡在网上的日子:http://www.jcodecraeer.com/member/content_list.php?channelid=1
- 邮箱:yangchong211@163.com
- 阿里云博客:https://yq.aliyun.com/users/article?spm=5176.100- 239.headeruserinfo.3.dT4bcV
- segmentfault头条:https://segmentfault.com/u/xiangjianyu/articles
转载于:https://my.oschina.net/zbj1618/blog/2253411
Android异步消息机制相关推荐
- android异步工作,Android异步消息机制详解
Android中的异步消息机制分为四个部分:Message.Handler.MessageQueue和Looper. 其中,Message是线程之间传递的消息,其what.arg1.arg2字段可以携 ...
- Android异步消息处理机制 全解析
Android异步消息处理机制主要是指Handler的运行机制以及Hanlder所附带的MessageQueue和Looper的工作过程. 本文将通过分析源码(api-28)的形式,全面解析Handl ...
- Android异步消息处理机制
Android异步消息常用汇总 android常用异步框架分为handler.AsyncTask.handlerThread.IntentService. 什么是handler android消息机制 ...
- 聊一聊Android的消息机制
2019独角兽企业重金招聘Python工程师标准>>> 聊一聊Android的消息机制 侯 亮 1概述 在Android平台上,主要用到两种通信机制,即Binder机制和消息机制,前 ...
- 【安卓学习笔记】Android Handler 消息机制探究
一.概述 1.android消息机制的含义: Android消息机制,其实指的就是 Handler 的运行机制,而 Handler 要正常运作,又需要底层的 MessageQueue , Looper ...
- EJB与JAVA BEAN_J2EE的异步消息机制
EJB与JAVA BEAN_J2EE的异步消息机制 EJB与JAVA BEAN的区别 Java Bean 是可复用的组件,对Java Bean并没有严格的规范,理论上讲,任何一个Java类都可以是一个 ...
- Android的消息机制(2)
上一节中,是主线程自己发了一个消息到自己的Message Queue中,并把消息从队列中提取出来.那么如何由别的线程发送消息给主线程的Message Queue中呢? 直接看代码~~ 1 2 3 4 ...
- Android的消息机制
Android的消息机制(一) android 有一种叫消息队列的说法,这里我们可以这样理解:假如一个隧道就是一个消息队列,那么里面的每一部汽车就是一个一个消息,这里我们先忽略掉超车等种种因素,只那么 ...
- Android的消息机制简单总结
参考文章: http://gityuan.com/2015/12/26/handler-message-framework/#next 参考资料: Android Framework的源码: Mess ...
最新文章
- Nature综述|预测生物学:微生物复杂性的解析、模拟与应用
- 修改mysql数据库编码
- sql server varchar最大长度_来自灵魂的拷问—知道什么是SQL执行计划吗?
- 【控制】《鲁棒控制-线性矩阵不等式处理方法》-俞立老师-第2章-线性矩阵不等式
- ASP.NET Core快速入门(第5章:认证与授权)--学习笔记
- 查找字符串末尾含关键字_EXCEL函数公式大全之利用FIND函数和RIGHT函数LEN函数取末尾字符...
- android异步编程,AsyncTask简单的异步编程android 中的实现
- C++读写注册表的问题
- mysql gps海拔表_GPS海拔表
- JS switch 分支语句
- 任务26:dotnet watch run 和attach到进程调试
- Atitit 技术领域之道 技术领域的艺术attilax著 v2 s66.docx Atitit 技术领域之道 attilax著 1. 分类	1 1.1. 按照架构 web cs桌面	1 1.2.
- Python Apex 武器自动识别与压枪 全过程记录
- 黑猫论坛实战免杀教程
- 中国石油大学《测井解释与生产测井》第三阶段在线作业
- GAE—图自编码器/Graph RNN/Graph RL
- 华三模拟器的错误使用方法
- 计算机操作系统的pv是什么意思,计算机操作系统关于PV操作的一道题
- 教你怎么在 Mac 电脑上进行语音实时输入
- java修改文件一行_java替换文件中某一行文本的内容