handler原理
一、消息机制概述
1.消息机制的简介
(1)Handler是什么
handler使Android给我们提供的用来更新UI的一套机制,也是一套消息处理机制;我们可以用它发送处理消息。
(2)Android为什么设计只能通过handler机制来更新ui?
最根本问题使解决多线程并发问题。假设一个activity由多个线程去更新UI,并且都没有加锁机制,那么会造成更新界面错乱。如果都加锁则会造成性能下降;
(3)在子线程中,进行耗时操作,执行完操作后,发送消息,通知主线程更新UI。这便是消息机制的典型应用场景。我们通常只会接触到Handler和Message来完成消息机制,其实内部还有两大助手来共同完成消息传递。
2.消息机制的模型
消息机制主要包含:MessageQueue,Handler和Looper这三大部分,以及Message,下面我们一一介绍。
Message:需要传递的消息,可以传递数据;
MessageQueue:消息队列,但是它的内部实现并不是用的队列,实际上是通过一个单链表的数据结构来维护消息列表,因为单链表在插入和删除上比较有优势。主要功能向消息池投递消息(MessageQueue.enqueueMessage)和取走消息池的消息(MessageQueue.next);
Handler:消息辅助类,主要功能向消息池发送各种消息事件(Handler.sendMessage)和处理相应消息事件(Handler.handleMessage);
Looper:不断循环执行(Looper.loop),从MessageQueue中读取消息,按分发机制将消息分发给目标处理者。
3.消息机制的架构
(1)消息机制的运行流程:在子线程执行完耗时操作,当Handler发送消息时,将会调用MessageQueue.enqueueMessage
,向消息队列中添加消息。当通过Looper.loop
开启循环后,会不断地从线程池中读取消息,即调用MessageQueue.next
,然后调用目标Handler(即发送该消息的Handler)的dispatchMessage
方法传递消息,然后返回到Handler所在线程,目标Handler收到消息,调用handleMessage
方法,接收消息,处理消息。
(2)MessageQueue,Handler和Looper三者之间的关系:每个线程中只能存在一个Looper,Looper是保存在ThreadLocal中的。主线程(UI线程)已经创建了一个Looper,所以在主线程中不需要再创建Looper,但是在其他线程中需要创建Looper。每个线程中可以有多个Handler,即一个Looper可以处理来自多个Handler的消息。 Looper中维护一个MessageQueue,来维护消息队列,消息队列中的Message可以来自不同的Handler。
从中我们可以看出:
Looper有一个MessageQueue消息队列;
MessageQueue有一组待处理的Message;
Message中记录发送和处理消息的Handler;
Handler中有Looper和MessageQueue。
二、消息机制的源码解析
1.Looper
UI线程的消息循环是在ActivityThread中的main()
方法中创建的,该函数是Android应用程序的入口,代码如下所示:
- public static void main(String[] args) {
- //代码省略
- Process.setArgV0("<pre-initialized>");
- Looper.prepareMainLooper();//创建Looper
- ActivityThread thread = new ActivityThread();
- thread.attach(false);
- if (sMainThreadHandler == null) {
- sMainThreadHandler = thread.getHandler();//UI线程的Handler
- }
- //代码省略
- Looper.loop();//执行消息循环
- throw new RuntimeException("Main thread loop unexpectedly exited");
- }
其中prepareMainLooper()方法会调用prepare(false)
方法。
无参情况下,默认调用prepare(true);
表示的是这个Looper可以退出,而对于false的情况则表示当前Looper不可以退出。。
- 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,只能创建一个。创建Looper,并保存在ThreadLocal。其中ThreadLocal是线程本地存储区(Thread Local Storage,简称为TLS),每个线程都有自己的私有的本地存储区域,不同线程之间彼此不能访问对方的TLS区域。
开启Looper
- public static void loop() {
- final Looper me = myLooper(); //获取TLS存储的Looper对象
- if (me == null) {
- throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
- }
- final MessageQueue queue = me.mQueue; //1.获取Looper对象中的消息队列
- Binder.clearCallingIdentity();
- final long ident = Binder.clearCallingIdentity();
- for (;;) { //2.进入loop的主循环方法(即消息循环)
- Message msg = queue.next(); //3.可能会阻塞,因为next()方法可能会无限循环
- if (msg == null) { //消息为空,则退出循环
- return;
- }
- Printer logging = me.mLogging; //默认为null,可通过setMessageLogging()方法来指定输出,用于debug功能
- if (logging != null) {
- logging.println(">>>>> Dispatching to " + msg.target + " " +
- msg.callback + ": " + msg.what);
- }
- msg.target.dispatchMessage(msg); //4.获取msg的目标Handler,然后用于分发Message (处理消息)
- if (logging != null) {
- logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
- }
- final long newIdent = Binder.clearCallingIdentity();
- if (ident != newIdent) {
- }
- msg.recycleUnchecked();
- }
- }
loop()实质上进入循环模式,不断重复从消息队列中逐个取出消息,最后处理消息的过程(如下描述),直到消息为空时退出循环:
循环过程:
- 读取MessageQueue的下一条Message(关于next(),后面详细介绍);
- 把Message分发给相应的target。
当next()取出下一条消息时,队列中已经没有消息时,next()会无限循环,产生阻塞。等待MessageQueue中加入消息,然后重新唤醒。
Looper总结:通过Looper.prepare()来创建Looper对象(消息队列封装再Looper对象中),并且保存在sThreadLocal中,然后通过Looper.loop()来执行消息循环,这两步通常是成对出现的。
2.Handler
在子线程完成耗时操作后,如果需要更新ui,最常用的方法就是通过HAndler将一个消息post大盘UI线程中,然后再在Handler的handlerMessage方法中进行处理,需要注意的是,该Handler必须在主线程中创建。
- class MyHandler extends Handler{
- @Override
- public void handleMessage(Message msg) {
- //更新UI
- }
- }
- MyHandler myHandler = new MyHandler();
- //开启新线程
- new Thread(){
- @Override
- public void run() {
- myHandler.sendEmptyMessage(123);
- }
- }.start();
每个Handler都会关联一个消息队列,消息队列被封装在Looper中,而每个Looper会关联一个线程(Looper通过ThreadLocal封装),最终就等于每个消息队列会关联一个线程。Handler就是一个消息处理器,将消息投递给消息队列,然后再由对应的线程的从消息队列中诸葛取出消息,并且执行。默认情况下,消息队列只有一个,即主线程的消息队列。那么Handler如何关联消息队列以及线程的呢?
- public Handler() {
- this(null, false);
- }
- public Handler(Callback callback, boolean async) {
- .................................
- //必须先执行Looper.prepare(),才能获取Looper对象,否则为null.
- mLooper = Looper.myLooper(); //从当前线程的TLS中获取Looper对象
- if (mLooper == null) {
- throw new RuntimeException("");
- }
- mQueue = mLooper.mQueue; //消息队列,来自Looper对象
- mCallback = callback; //回调方法
- mAsynchronous = async; //设置消息是否为异步处理方式
- }
对于Handler的无参构造方法,通过Looper.myLooper()方法,默认采用当前线程TLS中的Looper对象,并且callback回调方法为null,且消息为同步处理方式。只要执行的Looper.prepare()
方法,那么便可以获取有效的Looper对象。那么Looper.myLooper()怎么工作的:
- public static @Nullable Looper myLooper() {
- return sThreadLocal.get();
- }
- .........................
- //设置UI线程的Looper
- 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
- 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));
- }
从上述代码可以看出myLooper()是从sThreadLocal.get()获取的。而存储在prepare()方法完成。这样一来不同线程就不能访问对方的消息队列。
再回到Handler中来,消息队列通过Looper与线程关联上,而Handler又与Looper关联,因此Handler最终就和线程、线程的消息队列关联上了。这就解释了”为什么要更新UI的Handler必须再主线程中创建?“。就是因为Handler要与主线程的消息队列关联上,这样handlerMessage才会再UI线程执行,此时更新UI才是线程安全的。
3.发送消息
(1) Message
先看一下Message的源码:
- public final class Message implements Parcelable{
- public int what;
- public int arg1;
- public int arg2;
- public Object obj;
- public Messenger replyTo;
- /*package*/ int flags;
- /*package*/ long when;
- /*package*/ Bundle data;
- /*package*/ Handler target;//target处理
- /*package*/ Runnable callback;//Runnable类型的callback
- // sometimes we store linked lists of these things
- /*package*/ Message next;//下一条消息,消息队列是链式存储
- private static final Object sPoolSync = new Object();
- private static Message sPool;
- private static int sPoolSize = 0;
- private static final int MAX_POOL_SIZE = 50;
- private static boolean gCheckRecycle = true;
- }
- what:用户定义消息代码以便收件人可以识别这是哪一个Message。每个Handler用它自己的名称空间为消息代码,所以您不需要担心你的Handler与其他handler冲突。
- arg1、arg2:如果只是想向message内放一些整数值,可以使用arg1和arg2来代替setData方法。
- obj:发送给接收器的任意对象。当使用Message对象在线程间传递消息时,如果它包含一个Parcelable的结构类(不是由应用程序实现的类),此字段必须为非空(non-null)。其他的数据传输则使用setData(Bundle)方法。注意Parcelable对象是从FROYO版本以后才开始支持的。
- replyTo:指明此message发送到何处的可选Messenger对象。具体的使用方法由发送者和接受者决定。
ps:new Message和obtain的有什么区别:https://blog.csdn.net/dfskhgalshgkajghljgh/article/details/52672115
发送消息有几种方式,但是归根结底都是调用了sendMessageAtTime()
方法。
在子线程中通过Handler的post()方式或send()方式发送消息,最终都是调用了sendMessageAtTime()
方法。
(2)post方法
- public final boolean post(Runnable r)
- {
- return sendMessageDelayed(getPostMessage(r), 0);
- }
- public final boolean postAtTime(Runnable r, long uptimeMillis)
- {
- return sendMessageAtTime(getPostMessage(r), uptimeMillis);
- }
- public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
- {
- return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
- }
- public final boolean postDelayed(Runnable r, long delayMillis)
- {
- return sendMessageDelayed(getPostMessage(r), delayMillis);
- }
在post(Runnable r)时,会将Runnable包装成Message对象,并且将Runnable对象设置给Message对象的callback字段,最后将该Message对象插入到消息队列
(3)send方法
- public final boolean sendMessage(Message msg)
- {
- return sendMessageDelayed(msg, 0);
- }
- public final boolean sendEmptyMessage(int what)
- {
- return sendEmptyMessageDelayed(what, 0);
- }
- public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
- Message msg = Message.obtain();
- msg.what = what;
- return sendMessageDelayed(msg, delayMillis);
- }
- public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
- Message msg = Message.obtain();
- msg.what = what;
- return sendMessageAtTime(msg, uptimeMillis);
- }
- public final boolean sendMessageDelayed(Message msg, long delayMillis)
- {
- if (delayMillis < 0) {
- delayMillis = 0;
- }
- return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
- }
就连子线程中调用Activity中的runOnUiThread()中更新UI,其实也是发送消息通知主线程更新UI,最终也会调用sendMessageAtTime()
方法。
- public final void runOnUiThread(Runnable action) {
- if (Thread.currentThread() != mUiThread) {
- mHandler.post(action);
- } else {
- action.run();
- }
- }
如果当前的线程不等于UI线程(主线程),就去调用Handler的post()方法,最终会调用sendMessageAtTime()
方法。否则就直接调用Runnable对象的run()方法。
下面我们就来一探究竟,到底sendMessageAtTime()
方法有什么作用?
sendMessageAtTime()
- public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
- //其中mQueue是消息队列,从Looper中获取的
- MessageQueue queue = mQueue;
- if (queue == null) {
- RuntimeException e = new RuntimeException(
- this + " sendMessageAtTime() called with no mQueue");
- Log.w("Looper", e.getMessage(), e);
- return false;
- }
- //调用enqueueMessage方法
- return enqueueMessage(queue, msg, uptimeMillis);
- }
- private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
- msg.target = this;
- if (mAsynchronous) {
- msg.setAsynchronous(true);
- }
- //调用MessageQueue的enqueueMessage方法
- return queue.enqueueMessage(msg, uptimeMillis);
- }
可以看到sendMessageAtTime()`方法的作用很简单,就是调用MessageQueue的enqueueMessage()方法,往消息队列中添加一个消息。
下面来看enqueueMessage()方法的具体执行逻辑。
enqueueMessage()
- boolean enqueueMessage(Message msg, long when) {
- // 每一个Message必须有一个target
- 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) { //正在退出时,回收msg,加入到消息池
- msg.recycle();
- return false;
- }
- msg.markInUse();
- msg.when = when;
- Message p = mMessages;
- boolean needWake;
- if (p == null || when == 0 || when < p.when) {
- //p为null(代表MessageQueue没有消息) 或者msg的触发时间是队列中最早的, 则进入该该分支
- msg.next = p;
- mMessages = msg;
- needWake = mBlocked;
- } else {
- //将消息按时间顺序插入到MessageQueue。一般地,不需要唤醒事件队列,除非
- //消息队头存在barrier,并且同时Message是队列中最早的异步消息。
- 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;
- prev.next = msg;
- }
- if (needWake) {
- nativeWake(mPtr);
- }
- }
- return true;
- }
MessageQueue是按照Message触发时间的先后顺序排列的,队头的消息是将要最早触发的消息。当有消息需要加入消息队列时,会从队列头开始遍历,直到找到消息应该插入的合适位置,以保证所有消息的时间顺序。
4.获取消息
当发送了消息后,在MessageQueue维护了消息队列,然后在Looper中通过loop()
方法,不断地获取消息。上面对loop()
方法进行了介绍,其中最重要的是调用了queue.next()
方法,通过该方法来提取下一条信息。下面我们来看一下next()
方法的具体流程。
next()
- Message next() {
- final long ptr = mPtr;
- if (ptr == 0) { //当消息循环已经退出,则直接返回
- return null;
- }
- int pendingIdleHandlerCount = -1; // 循环迭代的首次为-1
- int nextPollTimeoutMillis = 0;
- for (;;) {
- if (nextPollTimeoutMillis != 0) {
- Binder.flushPendingCommands();
- }
- //阻塞操作,当等待nextPollTimeoutMillis时长,或者消息队列被唤醒,都会返回
- nativePollOnce(ptr, nextPollTimeoutMillis);
- synchronized (this) {
- final long now = SystemClock.uptimeMillis();
- Message prevMsg = null;
- Message msg = mMessages;
- if (msg != null && msg.target == null) {
- //当消息Handler为空时,查询MessageQueue中的下一条异步消息msg,为空则退出循环。
- do {
- prevMsg = msg;
- msg = msg.next;
- } while (msg != null && !msg.isAsynchronous());
- }
- if (msg != null) {
- if (now < msg.when) {
- //当异步消息触发时间大于当前时间,则设置下一次轮询的超时时长
- nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
- } else {
- // 获取一条消息,并返回
- mBlocked = false;
- if (prevMsg != null) {
- prevMsg.next = msg.next;
- } else {
- mMessages = msg.next;
- }
- msg.next = null;
- //设置消息的使用状态,即flags |= FLAG_IN_USE
- msg.markInUse();
- return msg; //成功地获取MessageQueue中的下一条即将要执行的消息
- }
- } else {
- //没有消息
- nextPollTimeoutMillis = -1;
- }
- //消息正在退出,返回null
- if (mQuitting) {
- dispose();
- return null;
- }
- ...............................
- }
- }
nativePollOnce是阻塞操作,其中nextPollTimeoutMillis代表下一个消息到来前,还需要等待的时长;当nextPollTimeoutMillis = -1时,表示消息队列中无消息,会一直等待下去。
可以看出next()
方法根据消息的触发时间,获取下一条需要执行的消息,队列中消息为空时,则会进行阻塞操作。
5.分发消息
在loop()方法中,获取到下一条消息后,执行msg.target.dispatchMessage(msg)
,来分发消息到目标Handler对象。
下面就来具体看下dispatchMessage(msg)
方法的执行流程。
从源码中可以看出,target是Handler类型,实际上就是转了一圈,通过Handler将消息投递给消息队列,消息队列又传给Handler来处理,继续看:
- /**
- * 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);
- }
- }
- private static void handleCallback(Message message) {
- message.callback.run();
- }
分发消息流程:
从上述程序可以看出,dispatchMessage只是一个分发的方法
当Message的msg.callback
不为空时,则回调方法msg.callback.run()
;
当Handler的mCallback
不为空时,则回调方法mCallback.handleMessage(msg)
;
最后调用Handler自身的回调方法handleMessage()
,该方法默认为空,Handler子类通过覆写该方法来完成具体的逻辑。
- threadHandler = new Handler(handlerThread.getLooper(), new Handler.Callback() {
- @Override
- public boolean handleMessage(Message msg) {
- //dosomething...
- return true;//1.true则不走handler的handleMessage;false则走
- }
- }) {
- @Override
- public void handleMessage(Message msg) {
- Log.d("handlerThreadActivity", handlerThread.getName() + "");
- }
- };
消息分发的优先级:
Message的回调方法:message.callback.run()
,优先级最高;
Handler中Callback的回调方法:Handler.mCallback.handleMessage(msg)
,优先级仅次于1;
Handler的默认方法:Handler.handleMessage(msg)
,优先级最低。
对于很多情况下,消息分发后的处理方法是第3种情况,即Handler.handleMessage()
,一般地往往通过覆写该方法从而实现自己的业务逻辑。
三、总结
以上便是消息机制的原理,以及从源码角度来解析消息机制的运行过程。可以简单地用下图来理解。
handler原理的更多相关文章
- Handler 原理分析和使用(二)
在上篇 Handler 原理分析和使用(一)中,介绍了一个使用Handler的一个简单而又常见的例子,这里还有一个例子,当然和上一篇的例子截然不同,也是比较常见的,实例如下. import andro ...
- Handler 原理分析和使用(一)
我为什么写Handler,原因主要还在于它在整个 Android 应用层面非常之关键,他是线程间相互通信的主要手段.最为常用的是其他线程通过Handler向主线程发送消息,更新主线程UI. 下面是一个 ...
- Handler 原理分析和使用之HandlerThread
前面已经提到过Handler的原理以及Handler的三种用法.这里做一个非常简单的一个总结: Handler 是跨线程的Message处理.负责把Message推送到MessageQueue和处理. ...
- Android Handler 原理
在android中提供了一种异步回调机制Handler,使用它,我们可以在完成一个很长时间的任务后做出相应的通知 handler基本使用: 在主线程中,使用handler很简单,new一个Handle ...
- Android中Handler原理
Handler主要是主线程和子线程通信.一般子线程中做一些耗时操作做完之后通知主线程来改动UI. 实际上android系统在Activity启动或者状态变化等都是通过Handler机制实现的. 首先进 ...
- Android - Handler原理
Handler的主要作用是收发消息和切线程 功能一:收发消息 简单流程介绍 希望你看完这篇文章后也可以把流程自己讲出来,并且每个环节还可以讲出很多细节 他的消息机制离不开Looper.MessageQ ...
- Android HttpURLConnection的使用+Handler的原理及典型应用
1.介绍 总结:HttpURLConnection用来发送和接收数据. 2.ANR异常报错 (1)ANR(Application not response) 应用无响应, 主线程(UI线程) (2)如 ...
- 从使用到原理学习Java线程池
线程池的技术背景 在面向对象编程中,创建和销毁对象是很费时间的,因为创建一个对象要获取内存资源或者其它更多资源.在Java中更是如此,虚拟机将试图跟踪每一个对象,以便能够在对象销毁后进行垃圾回收. 所 ...
- 2019 Android 高级面试题总结 从java语言到AIDL使用与原理
说下你所知道的设计模式与使用场景 a.建造者模式: 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 使用场景比如最常见的AlertDialog,拿我们开发过程中举例,比如C ...
随机推荐
- [CVPR2015] Is object localization for free? – Weakly-supervised learning with convolutional neural networks论文笔记
p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 13.0px "Helvetica Neue"; color: #323333 } p. ...
- mysql数据库死锁的产生原因及解决办法
这篇文章主要介绍了mysql数据库锁的产生原因及解决办法,需要的朋友可以参考下 数据库和操作系统一样,是一个多用户使用的共享资源.当多个用户并发地存取数据 时,在数据库中就会产生多个事务同时存取同 ...
- PAT1107:Social Clusters
1107. Social Clusters (30) 时间限制 1000 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue When ...
- socket和webService的区别
网络七层协议为:物理层.数据链路层.网络层.传输层.会话层.表示层.应用层 socket 只是 java在网络层定义的类,用来实现网络层.上面的各层需要我们自己在程序里实现. 例如端口可以自己定义 . ...
- Notify和NotifyAll的区别?
Notify和NotifyAll都是用来对对象进行状态改变的方式,只是他们的作用域不太一样,从字面上就能看的出来,当对象被上锁之后,当其他的方法要去访问该对象中的数据,就需要该对象对其进行解锁,当然, ...
- Python 时间模块
模块分类 标准库 python解释器自带的, sys, os等 开源模块 比如selenium中的测试框架 自定义模块 比如自己封装的测试框架 时间格式 时间戳 当前时间减去1970年1月1日00:0 ...
- index.go
package types type DocumentIndex struct { // 文本的DocId DocId uint64 // 文本的关键词长 TokenL ...
- string_array.go
package app import ( "strings" ) type StringArray []string func (a *StringArray) Set(s ...
- 【bzoj 1407】【Noi2002】Savage
Description Input 第1行为一个整数N(1<=N<=15),即野人的数目. 第2行到第N+1每行为三个整数Ci, Pi, Li表示每个野人所住的初始洞穴编号,每年走过的洞穴 ...
- Travel 并查集
题意:给一个图,若干询问,每次询问只经过边权<=w的边,x能到达的点数 并查集啊,对询问和边排序,直接合并,维护size,查询 #include<cstdio> #include&l ...