Android中Message对象复用原理

简介: Android开发中,我们经常使用Message对象,却很少去探求其复用池的实现原理,是时候揭开它的神秘面纱了!

Android 中 Message的应用

Message 在Android中主要是在 消息循环机制 中使用,即配合 Handler,LooperMessageQueue来进行线程切换,线程间传递数据;
以及配合Handler在IPC中传递数据; 这里不对这些进行展开,它不是我们关注的重点.

我们在代码中,被建议(网上或者前辈或看注释)用以下的方式来使用 Message,并且被告知,这样会提高性能.

Message msg = Message.obtain();

/**
     * Return a new Message instance from the global pool. Allows us to
     * avoid allocating new objects in many cases.
     */
    public static Message obtain();

嗯! 根据官方的文档,这样确实能够提高性能,将避免在大多数情况下创建新的对象!

下面我们来看它是如何实现高效的.

Message对象复用的实现

Message能提高效率的原因是,将使用完的Message清除附带的数据后,添加到复用池中,当我们需要使用它时,直接在复用池中取出对象使用,而不需要重新new创建对象. 而复用池本质上就是一个单向链表,为了更好的理解,Message复用池的实现,我们先来看下,简单的单向链表实现.

public class Linked<T> {
    // 链表的头节点
    private Node<T> head;
    // 链表的长度
    private int length;
    // 数据插入头部
    public void insertHead(T data) {
        Node<T> n = new Node<>();
        n.data = data;
        // 将所添加的节点的下一个节点指向头结点
        n.next = head;
        // 将头结点指向党员元素
        head = n;
        // 链表长度加1
        length++;
    }
    // 移除头部,并取出数据
    public T removeHead() {
        // 拿到原头结点
        Node<T> n = head;
        // 将头结点设置为下一个节点
        head = n.next;
        // 原头节点的下一个节点置空
        n.next = null;
        // 链表长度减1
        length--;
        // 返回原头结点数据
        return n.data;
    }
    public int getLength() {
        return length;
    }
    // 节点类
    static class Node<T> {
        T data; // 节点存放的元素
        Node<T> next; // 下一个节点的引用
    }
}

上面实现了单向链表的插入头部,和移除头部功能.
相信大家,对这种单向链表的实现,都十分熟悉,这里不再详细讲解,如果看不懂,请自行复习数据结构相关知识点.

下面我们带着上面的知识,来看Message中源码的实现.

// 只显示我们需要关注的代码
public final class Message implements Parcelable {
    ...
    // 下一个节点的引用
    Message next;
    // 这里起到类锁的功能,相当于 Message.class
    private static final Object sPoolSync = new Object();
    // 可以类比为 头结点
    private static Message sPool;
    // 链表的长度
    private static int sPoolSize = 0;
    // 链表的最大长度
    private static final int MAX_POOL_SIZE = 50;
    // 获取Message对象,类比单向链表的removeHead操作
    public static Message obtain() {
        // 同步锁, 这里相当于锁住 Message.class, 起到类锁的作用, 每一个Message实例都是同一把锁
        synchronized (sPoolSync) {
            // 链表中有可复用的Message,直接拿到头结点,然后将头结点指向下一个元素
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        // 链表中,没有可复用的message,直接new
        return new Message();
    }
    // 类比单向链表的insertHead操作
    void recycleUnchecked() {
        // 清空数据操作
        obj = null;
        ...
        // 同步锁
        synchronized (sPoolSync) {
            // 如果链表长度小于50,将当前结点,加入链表头部
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }
    ...
}

从上面的分析,我们来梳理一下整体的流程思想.

  • Message 使用一个静态变量,来起到头结点的作用.

静态变量属于类变量,内存中只会存在一份引用,正好能起到 头结点的作用

  • Message 将自身作为Node节点,存储下一个节点的引用,和自身数据
  • obtain()方法相当于链表中移除首元素,并返回该元素的操作

从复用池中获取Message避免了 new创建的消耗.

  • recycleUnchecked()方法相当于链表中将节点加入到头部的操作

添加到复用池之前,会先将Message中的数据清空.

  • Message添加了线程安全的操作
  • Message复用池最多保存50个使用完待复用的Message

50个可能是考虑到内存开销和时间开销的平衡, 不是将数据无限制的添加到复用池.


Message将自身作为节点, 使用一个静态变量作为头结点,让Message自身形成一个链表,而链表中存的是 已经清空数据的Message对象, 以这种方式起到复用的效果!

疑问

从代码中可以看出, Message中,将 private static final Object sPoolSync = new Object();作为锁标志,来起到类锁的作用.

它能起到类锁的作用是因为,static修饰的变量在类加载的初始化阶段就将被创建,final使得引用不可改变,从而达到 内存独一份的效果,进而起到和类锁同样的作用.

这里有个疑问, 为何不直接使用类锁来加锁呢? 使用上诉方式,反而需要new一个Object对象,不是增加开销吗?

// why not ???
synchronized (Message.class) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }

有答案的同学, 欢迎在评论区中指出!

引用

目录
相关文章
|
28天前
|
消息中间件 存储 Java
Android消息处理机制(Handler+Looper+Message+MessageQueue)
Android消息处理机制(Handler+Looper+Message+MessageQueue)
37 2
|
2月前
|
安全 Android开发 Kotlin
Android经典实战之SurfaceView原理和实践
本文介绍了 `SurfaceView` 这一强大的 UI 组件,尤其适合高性能绘制任务,如视频播放和游戏。文章详细讲解了 `SurfaceView` 的原理、与 `Surface` 类的关系及其实现示例,并强调了使用时需注意的线程安全、生命周期管理和性能优化等问题。
142 8
|
10天前
|
缓存 Java 数据库
Android的ANR原理
【10月更文挑战第18天】了解 ANR 的原理对于开发高质量的 Android 应用至关重要。通过合理的设计和优化,可以有效避免 ANR 的发生,提升应用的性能和用户体验。
31 8
|
19天前
|
消息中间件 存储 Java
Android消息处理机制(Handler+Looper+Message+MessageQueue)
Android消息处理机制(Handler+Looper+Message+MessageQueue)
43 2
|
6月前
|
Android开发 移动开发 小程序
binder机制原理面试,安卓app开发教程
binder机制原理面试,安卓app开发教程
binder机制原理面试,安卓app开发教程
|
28天前
|
XML 前端开发 Android开发
Android View的绘制流程和原理详细解说
Android View的绘制流程和原理详细解说
32 3
|
2月前
|
ARouter 测试技术 API
Android经典面试题之组件化原理、优缺点、实现方法?
本文介绍了组件化在Android开发中的应用,详细阐述了其原理、优缺点及实现方式,包括模块化、接口编程、依赖注入、路由机制等内容,并提供了具体代码示例。
42 2
|
2月前
|
编解码 前端开发 Android开发
Android经典实战之TextureView原理和高级用法
本文介绍了 `TextureView` 的原理和特点,包括其硬件加速渲染的优势及与其他视图叠加使用的灵活性,并提供了视频播放和自定义绘制的示例代码。通过合理管理生命周期和资源,`TextureView` 可实现高效流畅的图形和视频渲染。
194 12
|
29天前
|
Java 调度 Android开发
Android面试题之Kotlin中async 和 await实现并发的原理和面试总结
本文首发于公众号“AntDream”,详细解析了Kotlin协程中`async`与`await`的原理及其非阻塞特性,并提供了相关面试题及答案。协程作为轻量级线程,由Kotlin运行时库管理,`async`用于启动协程并返回`Deferred`对象,`await`则用于等待该对象完成并获取结果。文章还探讨了协程与传统线程的区别,并展示了如何取消协程任务及正确释放资源。
19 0
|
3月前
|
存储 监控 数据库
Android经典实战之OkDownload的文件分段下载及合成原理
本文介绍了 OkDownload,一个高效的 Android 下载引擎,支持多线程下载、断点续传等功能。文章详细描述了文件分段下载及合成原理,包括任务创建、断点续传、并行下载等步骤,并展示了如何通过多种机制保证下载的稳定性和完整性。
85 0