Android 消息机制

使用Handler中遇到的问题分析 引言 Only one Looper may be created per thread Cant create handler inside thread that has not called Looperprepare 为何主线程中创建handler就没问题 handler内存泄漏引言相信很多童鞋在使用handler的时候肯定遇到了不少的麻烦吧,比如: 1、Only one Looper m 阅读详情

异步消息处理

一、Looper

Looper负责的就是创建一个MessageQueue,然后进入一个无限循环体不断从该MessageQueue中读取消息,而消息的创建者就是一个或多个Handler 。

在构造方法中,创建了一个MessageQueue(消息队列)。

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

方法1. static void prepare() 静态的方法,准备
ThreadLocal中添加进一个新的对象,sThreadLocal是一个ThreadLocal对象,可以在一个线程中存储变量。prepare()中判断了当前线程的 Looper 对象是否为null,不为 null则抛出异常。这也就说明了一个线程Looper.prepare()方法不能被调用两次,同时也保证了一个线程中只有一个Looper实例

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
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));
}

方法2. loop() 方法

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

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(); // 可能阻塞,只有当 MessageQueue 调用 quit 方法时,next 方法才会返回 null,否则都会阻塞等待
        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
        Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }

        //使用调用 msg.target.dispatchMessage(msg);把消息交给msg的target的dispatchMessage方法去处理。
        msg.target.dispatchMessage(msg);

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

Looper 的静态方法 prepare() 中新建了一个 Looper 对象,Looper 的构造方法中初始化了 MessageQueue(新建) 、
且为 Thread 对象赋值(当前线程)。这两个对象是 Looper 对象持有的,每个 Looper 对象中都有一个 MessageQueue 和 当前线程对象,

prepare() 中将新建的 Looper 对象添加到了 ThreadLocal 对象中,这个对象是
static final ThreadLocal sThreadLocal = new ThreadLocal();
ThreadLocal 在类的最初就会实例化,在存储 Looper 的时候会以当前线程的对象作为一个参数,在取Looper
时也会通过当前线程来取

prepare() 方法中会判断当前线程是否已经绑定了 Looper 对象,如果绑定了则会抛出
throw new RuntimeException(“Only one Looper may be created per thread”);

在初始化 Handler 时也会根据当前线程判断是否绑定了 Looper ,如果没有绑定则会抛出
throw new IllegalStateException(“No Looper; Looper.prepare() wasn’t called on this thread.”);
通过这个过程,保证了每个线程只能绑定一个 Looper ,并且每个 Looper 都有一个 MessageQueue 对象

Looper.myLooper()获取了当前线程保存的 Looper 实例,然后在又获取了这个 Looper 实例中保存的
MessageQueue(消息队列),这样就保证了 handler 的实例与我们 Looper 实例中 MessageQueue 关联上了。

Looger.getMainLooper(); 获取主线程的 Looper 对象,主线程会自动调用 Looper.prepareMainLooper() 方法
完成 Looper 对象的绑定,并将该 Looper 对象赋值给一个静态的 Looper 变量,在调用 getMainLooper() 方法
时将该 Looper 对象返回。

Looper.myLooper() 方法是获取当前线程的 Looper 对象。

MessageQueue 的 next() 方法

MessageQueue 的 next() 方法中,除了取出 Java 层需要处理的 Message 对象,还会调用 nativePollOnce() 方法处理 Native 层的消息循环

native 层的消息循环在 MessageQueue 构造函数执行时启动,其构造函数会在 Native 层创建 Native.Looper 和 NativeMessageQueue,通过 Linux 的管道和 epoll 机制来实现

Linux 的管道可以看做是一个文件,并且包含读和写端,epoll 机制是如果一个线程读该文件时该文件没有内容,则该线程会进入等待,当另一个线程往该文件写内容后会唤醒正在读端等待的线程。这个等待和唤醒的机制就使用 Linux 的 epoll 机制

当 Java 层的 MessageQueue 获取消息的时候,也会调用 natice 层的 MessageQueue 从管道中读消息并且处理消息

创建 Native 层循环模型的原因:
Android 是支持纯 Native 开发的,并且 Android 系统的核心组件也是运行在 native 层的,各组件直接需要通信,所以建立两套循环机制就很重要

Looper主要作用:
  1. 与当前线程绑定,保证一个线程只会有一个 Looper 实例,同时一个 Looper 实例也只有一个 MessageQueue

  2. loop() 方法,不断从 MessageQueue 中去取消息,交给消息的 target 属性的 dispatchMessage 去处理

好了,我们的异步消息处理线程已经有了消息队列(MessageQueue),也有了 Looper 在无限循环体中取出消息,
现在缺的就是发送消息的对象了,发送消息的对象是 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());
        }
    }

    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 对象中有一个 Looper 对象和一个 MessageQueue 对象,这两个属性都是final 的在创建一个 Handler 对象的时候,如果当前线程没有绑定 Looper 对象,则会抛出异常 throw new RuntimeException(“Can’t create handler inside thread that has not called Looper.prepare()”);所以在一个线程中创建 Handler 的时候当前线程必须调用 Looper.prepare(); 方法

然后看我们最常用的sendMessage方法,方法最后调用了sendMessageAtTime,在此方法内部有直接
获取 MessageQueue 然后调用了 enqueueMessage 方法,我们再来看看此方法: enqueue : 入队

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {  
       msg.target = this;  
       if (mAsynchronous) {  
           msg.setAsynchronous(true);  
       }  
       return queue.enqueueMessage(msg, uptimeMillis);  
    }

enqueueMessage 中首先为 meg.target 赋值为this,【Looper的loop方法会取出每个msg然后交给 msg.target.dispatchMessage(msg) 去处理消息,也就是把当前的handler作为msg的 target 属性。

最终会调用 queue 的 enqueueMessage 的方法,也就是说 handler 发出的消息,最终会保存到消息队列中去。enqueueMessage 方法中使用 synchronize 锁 MessageQueue 对象,保证不同线程插入数据时的同步问题。

Looper 会调用 prepare() 和 loop() 方法,在当前执行的线程中保存一个 Looper 实例,这个实例会保存一个 MessageQueue 对象,然后当前线程进入一个无限循环中去,不断从 MessageQueue 中读取 Handler 发来的消息。然后再回调创建这个消息的 handler 中的 dispathMessage 方法

    public void dispatchMessage(Message msg) {  
        if (msg.callback != null) {  
            handleCallback(msg); // 使用创建 Message 时构造方法中的 Runnable 处理消息
        } else {  
            if (mCallback != null) {  
                if (mCallback.handleMessage(msg)) {  // 使用创建 Handler 时构造方法中的 Handler.Callback 处理消息
                    return;  
                }  
            }  
            handleMessage(msg);  // 重写的处理消息方法处理
        }  
    } 

这个流程已经解释完毕,让我们首先总结一下

  1. 首先Looper.prepare()在本线程中保存一个Looper实例,然后该实例中保存一个MessageQueue对象; 因为Looper.prepare()在一个线程中只能调用一次,所以MessageQueue在一个线程中只会存在一个。

  2. Looper.loop()会让当前线程进入一个无限循环,不断从 MessageQueue 的实例中读取消息,然后回调 msg.target.dispatchMessage(msg) 方法。

  3. Handler 的构造方法,会首先得到当前线程中保存的 Looper 实例,进而与 Looper 实例中的 MessageQueue 相关联。

  4. Handler的 sendMessage 方法,会给 msg 的 target 赋值为 handler 自身,然后加入 MessageQueue 中。

  5. 在构造 Handler 实例时,我们会重写 handleMessage 方法,也就是 msg.target.dispatchMessage(msg) 最终调用的方法。

好了,总结完成,大家可能还会问,那么在Activity中,我们并没有显示的调用 Looper.prepare() 和 Looper.loop() 方法,
为啥 Handler 可以成功创建呢,这是因为在 ActivityTherad 的 main() 方法中,已经为主线程调用了Looper.prepareMainLooper() 和 Looper.loop() 方法。

关于Handler处理消息的方式

  1. 创建 Message 对象时,指定 Runnable 对象,
    例如 Message.obtain(Handler handler, Runnable callback)

  2. 创建 Handler.Callback 实现类对象,并作为创建 Handler 的构造方法的参数

  3. 自定义类继承自 Handler,并重写 handlerMessage() 方法

以上3种方法的执行顺序:如果存在方式1,则由方式1直接处理;如果存在方式2,则方式2处理消息,且,如果方式2返回true,则处理完毕,否则,方式3也会处理消息。

Handler.post(); // 等多久执行… run() 方法中的代码

mHandler.post(new Runnable() {  
    @Override      
    public void run(){  
        og.e("TAG", Thread.currentThread().getName());  
        mTxt.setText("test");  
    }  
});  

然后 run 方法中可以写更新UI的代码,其实这个 Runnable 并没有创建什么线程,而是发送了一条消息,下面看源码:

public final boolean post(Runnable r)  {  
  return  sendMessageDelayed(getPostMessage(r), 0);  
}  

private static Message getPostMessage(Runnable r) {  
  Message m = Message.obtain();  
  m.callback = r;  
  return m;  
}   

可以看到,在 getPostMessage 中,得到了一个 Message 对象,然后将我们创建的 Runable 对象作为 callback 属性,赋值给了此 message.
- 注:产生一个Message对象,可以new ,也可以使用Message.obtain()方法;两者都可以,但是更建议使用obtain方法,
因为Message内部维护了一个Message池用于Message的复用,避免使用new 重新分配内存。
最终和handler.sendMessage一样,调用了sendMessageAtTime,然后调用了enqueueMessage方法,给msg.target赋值为 handler,最终加入MessagQueue.

  • msg的 callback 和target都有值,那么会执行哪个呢?
    如果 callback 不为null,则执行callback回调,也就是我们的Runnable对象

  • Handler 对象创建之后可以在任何线程中发消息,最终消息的处理都将回到 创建 Handler 时使用的 Looper 所在的线程处理。所以在子线程中可以使用主线程中创建的 Handler 对象发消息,在主线程中处理消息。

每个线程中可以创建多个 Handler ,处理消息时就调用 msg.targe 也就是 Handler 来处理,Looper 将消息发送给发送消息时使用的 Handler 对象来处理。子线程不可以直接创建 Handler, 必须在子线程先调用 Looper.prepare();线程中调用 Looper.loop(); 方法后才会开启轮循

一个线程中只能有一个 Looper ,也就是只能有一个 MessageQueue ,可以有多个 Handler。一个 Handler 可以在不同的线程中发送消息,但是消息的处理都是在创建 Handler 时使用的 Looper 所在的线程

总结

每个线程在绑定 Looper 之后都有一个 MessageQueue ,MessageQueue 中存着需要处理的消息 Message,Message 中存着处理消息的 Handler,Handler 在发消息时会将消息发送到自己所在线程的 MessageQueue,Looper 的 loop 方法就是开启 MessageQueue 的遍历。这样,Handler 所发的消息处理就会在 Handler 所在的线程中。

参考:http://blog.youkuaiyun.com/lmj623565791/article/details/47079737

详解Android的消息机制 Android的消息机制 本人初学Android,可能会因为文章中的一些错误而对您造成了困扰,万分抱歉,如有错误欢迎您在评论区指正。 文章目录Android的消息机制概述一、pandas是什么?二、使用步骤1.引入库2.读入数据总结 概述 Handler是Android消息机制的上层接口,所以Android的消息机制主要指的就是Handler的运行机制,其主要应用于UI线程(主线程)和子线程之间的交互。众所周知,一般情况下,出于安全的考虑,所有与UI控件的操作都要放在主线程,而一些耗时的I/O操作应 阅读详情

相关推荐

Android的消息机制

1.Android消息机制概述 1.1. Android消息机制是什么? Android消息机制主要是指Handler的运行机制以及Handler所附带的MessageQueue和Looper的工作工程,这三者实际上是一个整体,只不过我们在开发过程中比较多的接触到Handler而已。 1.2. Handler的主要作用 Handler的主要作用是将一个任务切换到Handler所在的线程中执行。比如我们经常碰到的一个场景:Android建议不要在主线程中进行耗时操作,否则会导致程序无法响应(A

u012684818的博客 750

Android问题笔记二十八:Only one Looper may be created per thread解决方法

专注于Android/Unity和各种游戏开发技巧,以及各种资源分享(网站、工具、素材、源码、游戏等)

空名先生 1748

java.lang.RuntimeException: Only one Looper may be created per thread解决方法

java.lang.RuntimeException: Only one Looper may be created per thread解决方法

是阿超 7030

源码的完全解析:Android的消息机制

每个线程仅仅可以创建一个Looper对象。 每个Looper对象可以对应多个hanlder对象。 每个Looper对象对应一个MessageQueue对象 每个MessageQueue维护一个Message链表 Message对象与发送消息的handler对象绑定。 Looper.prepare()执行在new Handler()前面 Looper.prepare()将新建的Looper对象保存在了当前线

Ricky的博客 679

内存优化--LOGBACK导致内存告警

一.故事背景 由于开辟新市场需要,开发了新的项部署在海外平台,其中最消耗内存的功能是消费kafka消息(最开始预计一天有1千万的量),部署完之后运行一段时间发现出现内存告警问题。 二.分析问题 出现内存告警,(新项目是低配置机器 2C4G * 2台)第一个念头是去查看堆空间设置的情况,看到jvm启动命令中堆空间都是直接指定大小,说明问题不是出在堆空间 -Xmx3g -Xms3g 先不管这些,去查看总的内存使用情况,发现总的内存空间使用将近有92% = 3.68G,那么这多出来使用的0.6

qq_33199919的博客 6053

5分钟搞定单细胞marker基因气泡图:scDotPlot保姆级教程(含Seurat适配)

本文提供了一份详细的scDotPlot R包使用教程,帮助用户在5分钟内完成单细胞marker基因气泡图的绘制。教程涵盖环境准备、Seurat和SingleCellExperiment对象的适配处理、进阶可视化技巧及自动化报告生成,特别适合生物信息学新手和临床研究者快速掌握这一高效的可视化工具。

weixin_29047545的博客 265

Android如何保证一个线程最多只能有一个Looper

if (l != null) throw new RuntimeException(“Only one Looper may be created per thread”); looperRegistry.put(currentThreadId, new Looper(true)); } } … } 上述方法对Looper.class对象进行了加锁,这些加锁开销有可能造成性能瓶颈。 有没有更好的方法实现Looper.prepare()方法?看一看Android的中Looper的源码。 public clas

m0_64319496的博客 978

无人机避障——Mid360+Fast-lio感知建图+Ego-planner运动规划(胎教级教程)

本工作将 Mid360 激光雷达、Fastlio-SLAM 和 Ego-Planner 集成,实现无人机的环境感知、定位建图和运动规划(仿真过程)—— 胎教级教程。

weixin_45390670的博客 1万+

安卓php推送消息机制,深入剖析Android消息机制原理

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

weixin_28803105的博客 190

保姆级教程:手把手配置AutoSar诊断复位(Dcm 0x11服务联动BswM/EcuM)

本文提供AutoSar诊断复位(Dcm 0x11服务联动BswM/EcuM)的保姆级配置教程,详细讲解从诊断服务基础配置到BswM规则引擎搭建、服务端口映射及EcuM复位执行的完整流程。通过Vector配置工具的实际截图和代码片段,帮助开发者高效实现远程复位功能,并分享调试技巧与性能优化实践。

weixin_30756499的博客 545

RK3576 PCIE接口调试:基于RTL8111HS的网卡驱动移植

检查项方法电源电压复位时序检查设备树 reset-gpios链路速率设备识别lspci -vvv驱动加载。

小灰灰的博客 740

安卓消息机制

【Android】消息机制

qq_33512072的博客 1456

【施磊】C++课程笔记目录

【C++编程】施磊老师C++笔记目录

GeniusAng的博客 4128

安卓开发中Android消息机制详解

在Android程序运行中,线程之间或者线程内部进行信息交互时经常会使用到消息,如果我们熟悉这些基础的东西及其内部的原理,将会使我们的Android开发变的容易、可以更好地架构系统。在学习Android消息机制之前,我们先了解与消息有关的几个类:   1.Message   消息对象,顾名思义就是记录消息信息的类。这个类有几个比较重要的字段:   a.arg1和arg2:我们可以

zhangkongzhongyun的专栏 621

152:vue+leaflet 判断一个点是否在一个电子围栏内

本文介绍了一个基于Vue+Leaflet的示例,演示如何判断点是否在电子围栏内。作者大剑师兰特(优快云知名博主)展示了使用polygon.getBounds().contains(latlng)方法检测点与多边形边界的关系。代码仅需80行,通过点击地图触发判断逻辑,结果显示提示信息。该技术可广泛应用于地理围栏、位置服务等场景,需要安装turf依赖。文章提供了完整源码和配置说明,适合GIS开发者学习参考。

大剑师兰特的GIS世界 759

39、高频 LLC 谐振转换控制系统动态优化算法分析与研究

本文针对高频下LLC谐振转换器动态性能差的问题,提出一种基于谐振电容器充放电估计动态切换时间的优化控制算法。通过改进状态轨迹控制方法,突破传统算法在谐振频率与开关频率相等条件下的限制,并结合新型采样策略有效抑制电压过冲。算法在MATLAB和SABER中完成仿真验证,并搭建基于STM32F407的原型系统进行测试,结果表明该方法显著缩短动态响应时间,提升系统稳定性。研究为高频、高功率密度开关电源的动态优化提供了可行解决方案。

linux6sysadmin的博客 113

【安卓学习笔记】Android Handler 消息机制探究

一、概述 1.android消息机制的含义: Android消息机制,其实指的就是 Handler 的运行机制 而 Handler 要正常运作,又需要底层的 MessageQueue , Looper , ThreadLocal 共同配合 因此所谓的消息机制,其实主要讲的就是 Handler ,MessageQueue ,Looper ,ThreadLocal 四者的关系 2.概述Handler工作流程: 首先是构造 Handler ,这时候会通过 ThreadLocal 找到当前线程的 Looper

tulensa的博客 1499

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Android消息机制-Java层梳理_java 安卓 队列消息

此分析是基于android12源码的情况下进行Android系统两大核心机制Binder机制和消息机制消息系统涉及的核心类Android的系统组件启动、输入、UI刷新都需要通过消息机制来实现,某种意义上讲Android是由消息系统来驱动通过传送带机制来理解。

2501_90256561的博客 381

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Android消息机制

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

weixin_58719774的博客 2055

《Android开发艺术探索》之安卓的消息机制(十二)

第十章 Android的消息机制 Handler的说明如下:有时候需要子线程去进行耗时I/O操作,譬如读取文件、访问网络。耗时操作完成后需要在UI上做一些改变,但我们并不能在子线程中更新UI,通过Handler可以更新UI操作并切换至主线程...

云瀚的自习室 621

安卓php推送消息机制,利用Android的消息机制实现线程同步

个人认为线程,多线程同步问题可以简单概括成如下一个问题:“共有资源,如何才能在2个以上的线程中安全读写?”本文通过逐步回答以下的两问题,来最终解决上面这个最根本的问题:1 为什么是消息机制?2 凭什么说是线程安全的?下面,将会以主线程(即UI线程)与普通子线程的同步为例进行说明。一 为什么是消息机制因为消息机制,有实现线程间通信的能力。并且我们可以肯定,handleMessage()函数会在Han...

weixin_28878621的博客 190
上一篇: Activity 进阶
下一篇: HandlerThread 与 IntentService 源码分析
任教主来也
博客等级 码龄11年 12粉丝 28原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值