序列化与内存相关知识体系详解

1 阅读49分钟

此文档由AI生成

本文档整理自一系列关于 Android/Java 序列化机制的问答,涵盖:序列化原理与实现、字节流/字节码/二进制流、Parcel、Serializable 及其对比。


目录

  1. 序列化:概念、原理与实现
  2. Java 进程的虚拟内存模型
  3. 字节流、字节码、二进制流:概念与区别
  4. Parcel:概念、原理与实现
  5. Serializable:概念、原理与实现
  6. Parcel 与 Serializable 的区别

一、序列化:概念、原理与实现

1.1 什么是序列化

序列化:把内存中的对象转换成**可传输、可存储的字节序列(或文本格式)**的过程。 反序列化:把字节序列恢复成对象的过程。

内存中的对象          序列化           字节流/文本
┌────────────┐      ─────────▶     ┌──────────────┐
│ User对象    │                     │ 01100101...  │
│ name="Tom"  │      ◀─────────     │ 或 JSON 文本  │
│ age=18      │      反序列化        └──────────────┘
└────────────┘                     可存磁盘/网络传输

1.2 为什么内存中的对象不能直接传输和存储

对象无法直接跨越进程/机器/时间边界,有四个根本原因:

原因说明
指针只在当前进程有效对象内部充满引用(如 friends 字段存的是堆中另一对象的虚拟地址)。地址是进程私有的、随机的(ASLR、GC 移动),磁盘和网络上没有"内存总线"这个概念
内存布局是实现细节对齐/填充、字节序(大端/小端)、运行时对象头、压缩指针(4/8 字节)、字符串编码(UTF-8/UTF-16)都因运行时和硬件而异
对象引用"活的环境"文件句柄、Socket、数据库连接、线程等指向操作系统内核资源,离开原进程毫无意义
生命周期与边界进程隔离(操作系统安全基石)、网络传输、磁盘持久化,跨过这三条边界只有一种公共货币:自描述的字节序列

一句话:内存中的对象 = 数据 + 指向本进程内存的引用 + 依赖特定运行时的布局。序列化就是把"引用"摊平成数据、把"私有布局"翻译成"公开协议"。

1.3 序列化要解决的核心问题

问题说明
格式字节怎么排列?谁先谁后?大端还是小端?(即"协议")
对象图对象引用了其他对象怎么办?循环引用(A→B→A)如何处理?
类型信息反序列化时如何知道该还原成哪个类?
版本兼容类定义变了(加减字段),旧数据还能读吗?
安全性反序列化不可信数据可能执行任意代码(Java 反序列化漏洞)

不同序列化方案本质上是对这些问题做出不同的取舍。

1.4 序列化的两大用途

  1. 持久化:对象 → 磁盘(保存状态、缓存)
  2. 传输:对象 → 网络/进程间(RPC、IPC、消息队列)

注意:这是通用序列化的定位。像 Parcel 这样的专用序列化会刻意收窄问题域(详见第四章)。

1.5 Java 生态的常见序列化方案

方案一:java.io.Serializable(JDK 内置)

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient String password; // transient 字段不序列化
}
  • 机制:基于反射,自动遍历对象图,写出类的元数据(类名、字段描述、serialVersionUID)+ 字段值。
  • 优点:零配置,开箱即用。
  • 缺点:慢(反射)、体积大(带大量元数据);serialVersionUID 不匹配抛 InvalidClassException;安全风险大(反序列化不可信数据可构造攻击链)。

方案二:Parcelable(Android 专属)

public class User implements Parcelable {
    public String name;
    public int age;

    protected User(Parcel in) {
        name = in.readString(); // 读的顺序必须和写的顺序一致!
        age = in.readInt();
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);
    }

    public static final Creator<User> CREATOR = new Creator<User>() {
        @Override
        public User createFromParcel(Parcel in) { return new User(in); }
        @Override
        public User[] newArray(int size) { return new User[size]; }
    };

    @Override
    public int describeContents() { return 0; }
}
  • 机制:无反射,直接把字段按手写的顺序写进连续内存(native 层实现),配合 Binder 直接传内存。
  • 限制:只用于同一设备内存中传输(IPC、Bundle),不能落盘、不能跨网络,不保证跨版本兼容。

Kotlin 中用 @Parcelize 注解可自动生成全部样板代码。

方案三:文本格式(JSON / XML)

{"name": "Tom", "age": 18}
  • 人类可读、跨语言,Web 事实标准。常用库:Jackson、Gson、Moshi、FastJSON。
  • 缺点:体积和速度不如二进制方案;JSON 没有类型系统。

方案四:二进制跨语言格式(Protobuf / Thrift / Hessian)

message User {
  string name = 1;
  int32 age = 2;
}
  • 用 schema 定义结构,编译生成各语言代码。
  • 体积小(varint 编码)、解析极快、天然带版本兼容机制(按字段编号 tag 读写)。
  • gRPC 的底层就是 Protobuf。

方案五:Externalizable

Serializable 的手动版,自己实现 writeExternal() / readExternal(),思路与 Parcelable 类似。

1.6 方案对比总表

方案性能体积跨语言安全性适用场景
Serializable慢(反射)大否(仅JVM)差简单持久化、深拷贝
Parcelable很快小否较好Android IPC/Bundle
JSON中中是取决于库Web API、配置、调试
Protobuf很快很小是较好RPC、存储、跨服务通信

1.7 实践要点

  1. 深浅拷贝:序列化再反序列化一遍,天然实现深拷贝(注意性能)。
  2. transient:标记不需要序列化的字段——密码、缓存、连接句柄。
  3. 版本兼容:
    • Serializable 靠 serialVersionUID,规则脆弱;
    • Protobuf 靠字段编号,永远不要复用已使用的编号;
    • JSON 按"缺失字段给默认值"的宽容策略解析。
  4. 安全红线:永远不要反序列化不可信来源的 JDK 原生序列化数据(ObjectInputStream.readObject)。
  5. Android 选型口诀:
    • Intent / Bundle / AIDL 传数据 → Parcelable;
    • SharedPreferences / 文件 / 网络 → JSON 或 Protobuf;
    • 数据类用 @Parcelize 避免手写样板代码。

1.8 补充:对象中的"函数"如何序列化?

答案:通常不序列化。 序列化只针对"状态",不针对"行为":

  • 一个对象 = 状态(实例字段,存在堆里)+ 行为(方法,存在类的定义里,所有实例共享一份);
  • 序列化协议传输的是对象快照(数据),代码是部署问题,不是序列化问题;
  • Serializable 流里只写"类名 + 字段描述 + 字段值",不含方法字节码;反序列化端从自己的 classpath 加载类;
  • JSON 直接忽略方法;JavaScript 的 JSON.stringify 同样丢弃函数。

如果确实需要"传输行为",业界做法:

  1. RPC:两端各自部署方法代码,网络上只传"接口名 + 方法名 + 参数值";
  2. 规则引擎/DSL:把逻辑降级成数据(SQL、SpEL、JSON 规则),远端解释执行;
  3. 动态加载代码:单独传输 .class/jar/dex,用 ClassLoader 加载(OSGi、热修复)——这是代码分发,与序列化是两个机制,且有严重安全隐患;
  4. Java lambda 若目标接口继承 Serializable 可被序列化,但流里只写"类名+方法名"引用,不写字节码。

1.9 补充:元数据、反射、类信息存储与对象的内存布局

要真正理解 Serializable 为什么慢、Parcel 为什么快,必须先搞清楚四个底层概念:元数据、反射、类信息的存储、对象的内存布局。它们是一条因果链:

类信息加载到内存 → 对象在堆上按布局创建 → 反射读取类元数据操作对象 → 序列化框架基于反射(或绕开它)

1.9.1 什么是元数据(Metadata)

元数据 = "描述数据的数据"(data about data)。它不承载业务内容本身,而是描述内容的结构、类型、来源、约束。

场景数据(内容本身)元数据(描述内容的信息)
数据库表里的 Tom, 18表结构:name VARCHAR(20), age INT
图片文件像素阵列EXIF:拍摄时间、相机型号、分辨率
JSON"Tom"键名 "name"(键就是轻量级元数据)
Protobuf字段值.proto schema:string name = 1;
Java 序列化流字段值 "Tom"、18类名、字段名、类型签名、serialVersionUID
.class 文件方法体的字节码指令魔数、版本号、常量池、字段/方法表

为什么序列化离不开元数据:字节流本身没有类型概念(回顾第三章),接收方要"正确还原",必须知道"每个字节是什么类型、属于哪个字段、按什么顺序排列"。这些描述信息就是元数据——自描述格式(Serializable、Protobuf)显式携带元数据,因此通用但臃肿;Parcel 不携带元数据,因此轻快但只能按约定位置解析。这个取舍贯穿所有序列化方案。

1.9.2 反射(Reflection)的概念和原理

概念:反射是指在运行时(而非编译期)动态地检查和操作类的能力——程序可以在不知道类具体定义的情况下,获取它的类名、字段、方法、构造器,甚至调用方法、修改字段值。API 位于 java.lang.reflect 包。

User user = new User("Tom", 18);
Class<?> clazz = user.getClass();          // 拿到 Class 对象(类的运行时"镜像")

// 获取类元数据
System.out.println(clazz.getName());       // "com.example.User"
for (Field f : clazz.getDeclaredFields()) {
    System.out.println(f.getName() + " : " + f.getType()); // name : String ...
}

// 动态操作对象——绕过编译期检查
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true);             // 甚至能访问 private 字段(打破封装!)
nameField.set(user, "Jerry");              // 等价于 user.name = "Jerry"

// 动态创建实例
Object newUser = clazz.getDeclaredConstructor().newInstance();

原理——一切基于"Class 对象 + 元空间中的类元数据":

  1. 类加载时,JVM 把 .class 文件解析成运行时类元数据结构,存入方法区(Java 8 后为元空间 Metaspace,见 1.9.3);
  2. 同时在 Java 堆上创建一个 java.lang.Class 对象,作为这些元数据的"入口句柄"——每个类在运行时有且只有一个 Class 对象;
  3. getClass()、Xxx.class、Class.forName("...") 三种方式拿到的都是这个 Class 对象;
  4. getDeclaredFields() 等调用,本质是 JNI/本地方法去读元空间里的字段表;
  5. field.set(obj, value) 底层由 JVM 的本地实现完成:先做访问权限检查(setAccessible(true) 可跳过),再按字段在对象内存布局中的**偏移量(offset)**直接读写堆内存。

为什么反射慢:

开销来源说明
安全检查每次 Field.get/set、Method.invoke 都做访问权限检查
装箱/拆箱Method.invoke 参数是 Object[],基本类型要装箱
方法分发通过 MethodAccessor 间接调用,早期实现无法内联优化(现代 JVM 会为热点反射调用生成字节码桩,但仍有首次开销)
无法静态优化编译器看不懂反射目标,不能内联、逃逸分析受限

这正是 Serializable 慢的根源(每个对象、每个字段都走一遍上述流程),也是 Android 设计无反射 Parcelable 的直接动机。

1.9.3 类信息是如何存储的

加载链条:.class 字节流 → ClassLoader 读取 → 校验(魔数、版本、字节码合法性)→ 解析成运行时结构 → 存入方法区,同时在堆上创建 Class 对象。

JVM 运行时数据区中,各类信息分别存在哪(以 HotSpot 为例):

存储内容存储位置说明
类元数据(类名、父类、接口、字段表、方法表、字节码指令、访问标志)方法区(Java 8+ 实现:元空间 Metaspace,使用本地内存,不再有永久代大小限制)反射读取的就是这里
静态变量(static 字段)Java 堆(JDK 7 起从永久代移到堆中)所以 static 字段不参与对象序列化——它不属于任何实例
运行时常量池(字符串字面量、符号引用)元空间中的运行时常量池区.class 文件里的常量池在加载后解析进来;字符串字面量再指向堆中的字符串常量池
java.lang.Class 对象Java 堆元数据的"堆上入口",GC 管理的普通对象
对象实例、数组Java 堆(分代:Eden → Survivor → Old)1.9.4 详细讲
局部变量、对象引用虚拟机栈(线程私有,栈帧中)栈上的变量存的是引用(地址),不是对象本身
JIT 编译后的机器码代码缓存(Code Cache)与字节码并存

Android(ART)的差异:APK 里的 .dex 由 ART 在安装时 AOT 编译(或运行时 JIT),类元数据和方法体存进进程私有的内存映射;framework.jar 的类(如 Parcel)由系统预加载(zygote 进程启动时加载并 fork 共享),所以每个 App 进程"天生"就有框架类可用。

关键理解——符号引用到直接引用:.class 常量池里存的是符号引用(字符串形式的 "com/example/User"),类加载的链接阶段把符号引用解析成直接引用(真实内存地址/偏移量)。反射拿到的元数据、字节码执行时的方法调用,最终都落到这些直接引用上。

补充:类的加载时机——按需加载,不是一次性全部加载

结论:JVM 采用懒加载(Lazy Loading)。启动时不会把所有类一次性读进内存,而是在第一次真正用到某个类时才加载它。JVM 规范对"何时加载"没有硬性规定(留给实现自由),但严格规定了"何时必须初始化"——所以完整答案是:加载时机由实现决定(HotSpot 选择按需),初始化时机由规范强制。

先区分三个容易混淆的阶段:

加载 Loading          链接 Linking                        初始化 Initialization
┌──────────────┐   ┌──────────────────────────────┐   ┌────────────────────┐
│ 读取 .class 字节流│ → │ 验证 → 准备 → 解析            │ → │ 执行 <clinit>       │
│ 生成方法区结构    │   │ (符号引用→直接引用在此阶段)    │   │ static 赋值 + 静态块 │
│ 堆上创建 Class 对象│  │ 准备阶段: static 字段赋零值    │   │ (按需、仅一次)      │
└──────────────┘   └──────────────────────────────┘   └────────────────────┘
        ↑ 可以发生得很早(甚至预加载)                      ↑ 懒:第一次"主动使用"

① 触发初始化(加载必然已发生)的六种"主动使用":

场景示例
new 创建实例new User()
读取/设置非 final 常量的静态字段User.count++、System.out
调用静态方法User.staticMethod()
反射调用(默认初始化)Class.forName("com.example.User")
初始化子类时,先初始化父类new SubUser() → 先初始化 User
作为启动类 / 含 main 方法的类java com.example.Main

② 不触发初始化的"被动使用"(重要陷阱):

User[] arr = new User[10];              // 只加载数组类,不初始化 User
System.out.println(SubUser.parentName); // 通过子类引用父类静态字段 → 只初始化父类
public static final int MAX = 100;      // 编译期常量:编译时被"内联"进调用方字节码,
                                        // 调用方根本不引用 User 类 → 完全不会初始化

③ Class.forName vs ClassLoader.loadClass:

Class.forName("com.example.User");      // 加载 + 初始化(会执行 static 块)
ClassLoader.loadClass("com.example.User"); // 只加载,不初始化(JDBC 旧式驱动注册用前者,
                                            // Spring 扫描用后者避免副作用)

④ "按需"的粒度到什么程度:

  • 加载:ClassLoader 按需从 classpath 读取单个 .class 文件(不是扫描整个 jar);
  • 解析:HotSpot 默认懒解析——符号引用在方法第一次执行时才解析成直接引用(也可 -Xverify 等参数影响验证时机);
  • 预加载的部分:JVM 启动时必须加载一批核心类(java.lang.Object、String、Class、System 等),否则连 main 都无法执行;此外 -javaagent、premain 会提前加载一批类;
  • CDS / AppCDS:把一批常用类的元数据快照归档到文件,启动时直接 mmap 映射,省去解析开销——加速的正是"加载 + 链接"这一步。

⑤ 为什么"启动慢"和"懒加载"不矛盾:

框架(Spring 扫描、依赖注入容器、ARouter 等)会在启动时主动 loadClass 大量类去读注解/元数据——这是框架的行为,不是 JVM 一次性加载了所有类。也正因如此,启动优化手段通常是减少扫描范围、延迟初始化(@Lazy)、或用 baseline profile 提前预热。

⑥ Android(ART)上的差异:

  • APK 里的类打包成 .dex(不是一个个 .class),ART 启动时 mmap 整个 dex,但解析/验证仍是按需的;安装时 AOT 编译(Android 7+ 改为混合 JIT/AOT)会把热点方法编译成机器码;
  • 类加载器层级不同:BootClassLoader(框架类)→ PathClassLoader / DexClassLoader(应用类),框架类由 zygote 预加载并 fork 共享,所以 App 启动时"已经"有 Parcel 等类可用,无需自己加载;
  • 启动优化常用 Baseline Profile / Profile-guided AOT,本质就是把"按需加载 + JIT"的热点路径提前编译好。

⑦ 与序列化的关联:

  • 反序列化时(ObjectInputStream.readObject、Gson/Jackson 解析前),框架必须先加载目标类(Class.forName / 反射),这就是 Serializable 跨端时必须"对端有同一个类"的机制所在——类找不到就抛 ClassNotFoundException,数据传到了也没用;
  • 反过来,"只加载不初始化"正是序列化框架的安全用法:先 loadClass 拿到类元数据、读注解,避免触发对方的 static 初始化副作用(所以很多框架用 ClassLoader.loadClass 而不是 Class.forName)。

1.9.4 对象在内存中是如何存储的

对象只存在于堆上;栈上的变量持有的是引用(地址)。

虚拟机栈(线程私有)                Java 堆
┌──────────────┐
│ User user ───┼──────────────▶  0x7f3a1000 ┌──────────────────┐
└──────────────┘                             │ 对象头 Header      │
                                             │  ├ Mark Word      │ ← 哈希码/GC年龄/锁状态
                                             │  └ 类型指针        │ → 指向元空间的类元数据
                                             ├──────────────────┤
                                             │ 实例数据           │
                                             │  ├ name引用 ──────┼──▶ 堆中另一对象 "Tom"
                                             │  └ age = 18       │
                                             ├──────────────────┤
                                             │ 对齐填充 Padding   │ ← 补齐到8字节倍数
                                             └──────────────────┘

三部分结构(HotSpot 64 位,开启压缩指针):

  1. 对象头(Header,12 字节):
    • Mark Word(8 字节):哈希码、GC 分代年龄、锁标志位( synchronized 优化就靠它);
    • 类型指针(4 字节,压缩后):指向元空间中的类元数据——这就是 getClass() 和反射能工作的物理基础;
    • 数组对象额外多 4 字节长度字段。
  2. 实例数据(Instance Data):各字段按类型写入——引用 4 字节(压缩指针)、int 4 字节、long/double 8 字节、boolean 1 字节;字段排列有重排序规则(相同宽度聚集,父类字段在前);
  3. 对齐填充(Padding):补齐到 8 字节的整数倍(CPU 缓存行友好)。

算一个例子(64 位 JVM,压缩指针开启):

class User { String name; int age; }

对象头    12 字节(Mark Word 8 + 类型指针 4)
name引用   4 字节
age       4 字节
────────────────────
合计      20 字节 → 对齐填充 4 字节 → 实际占用 24 字节

(注意:name 字段的 4 字节只是引用,真正的字符串 "Tom" 是堆上的另一个对象。)

对象图与序列化的关系——现在可以精确定义"序列化摊平对象图"了:

堆内存(地址相互引用)                    序列化后(引用全部摊平为数据)
User ──name──▶ String "Tom"           [类元数据][name="Tom"][age=18]
  └─friends─▶ [User "Jerry"]   ──▶    [friends=[User "Jerry"]]
       └─name──▶ String "Jerry"
  • 堆中对象靠地址引用组织成网状图,地址离开本进程即失效;
  • 序列化把整个对象图递归展开成一棵树/一段线性字节,所有引用变成内联数据(Serializable 还会为重复引用写引用编号、处理循环);
  • 反序列化则在对端的堆上重建一套全新的对象 + 新的地址,旧地址信息完全丢弃。

串联回前面所有结论:

前面的问题现在的底层解释
为什么内存对象不能直接传输对象图靠进程私有地址组织,且布局含运行时私有信息(对象头、对齐)
为什么 Serializable 慢反射遍历字段表(元空间查询)+ 每字段装箱 + 无法内联优化
为什么反射能访问 private 字段访问检查在运行时由 Field.set 的本地实现控制,setAccessible(true) 可跳过
为什么 transient/static 不序列化前者是序列化协议在遍历字段时跳过;后者存在堆中静态存储区,不属于实例
为什么 getClass() 能拿到类信息对象头中的类型指针指向元空间的类元数据,Class 对象是其堆上入口
为什么 Parcel 快完全绕开上述反射链路:不查字段表、不装箱,按手写顺序直接按偏移量写连续内存

二、Java 进程的虚拟内存模型

本章解释 1.9.3 / 1.9.4 中的"方法区、元空间、堆、栈"到底位于哪里——它们都是 Java 进程虚拟地址空间中的一部分。理解了这张"地图",前面的对象布局、反射原理、甚至 MMKV 的 mmap,就都有了物理落脚点。

2.1 先澄清一个术语陷阱

"Java 内存模型"(JMM,JSR-133)指的是并发模型:volatile、synchronized 的可见性/有序性规则——不是本章内容。本章讲的是 Java 进程的虚拟内存布局:一个 JVM 进程的虚拟地址空间是怎么划分、分层的。

2.2 全景:四层视角看内存

一个 Java 对象的"家",从下到上跨了四层,每层各管一段:

┌─────────────────────────────────────────────────┐
│ 第4层  JVM 运行时数据区                             │  ← JVM 规范定义的语言层划分
│        堆 / 虚拟机栈 / 方法区(元空间) / PC / 直接内存  │     (对象、栈帧、类元数据住在这里)
├─────────────────────────────────────────────────┤
│ 第3层  进程虚拟地址空间                              │  ← OS 给每个进程的"假象"
│        text / data / bss / heap / mmap / stack     │     (JVM 只是普通进程,住在这一层里)
├─────────────────────────────────────────────────┤
│ 第2层  OS 内存管理                                  │  ← 内核机制
│        页表 / 分页(4KB) / mmap / 写时复制COW / swap  │
├─────────────────────────────────────────────────┤
│ 第1层  物理内存 + MMU 地址翻译                       │  ← 硬件
│        真实的 RAM 芯片、缓存行                       │
└─────────────────────────────────────────────────┘

第 1、2 层的基础(虚拟内存机制):

  • 每个进程拥有独立的虚拟地址空间(64 位 Linux 下理论 2^48 字节),程序里看到的地址全是虚拟地址;
  • MMU 通过页表把虚拟页翻译成物理页帧,按需调页(访问到还没分配的页才真正分配物理内存);
  • 这带来了三样东西:进程隔离(进程 A 无法访问进程 B 的地址——序列化存在的原因之一)、按需分配(reserve 不等于占用)、灵活性(mmap 可把文件映射进地址空间)。

2.3 JVM 规范视角:运行时数据区的结构

JVM 规范把进程内存划分为五个区域,按线程私有 / 线程共享分为两组:

                    ┌─────────────── 线程共享 ───────────────┐
                    │  ┌──────────────────────────────────┐ │
                    │  │ 堆 Heap                          │ │
                    │  │  Eden │ Survivor0 │ Survivor1     │ │
                    │  │  ───────────────────────────      │ │
                    │  │  Old(老年代)                     │ │
                    │  └──────────────────────────────────┘ │
                    │  ┌──────────────────────────────────┐ │
                    │  │ 方法区(Java8+ = 元空间 Metaspace) │ │
                    │  │   └ 运行时常量池                   │ │
                    │  └──────────────────────────────────┘ │
                    └───────────────────────────────────────┘
┌─────────── 线程私有(每线程一份)──────────────────────────┐
│  程序计数器 PC   │  虚拟机栈(栈帧×N)  │  本地方法栈        │
│  当前指令地址    │  局部变量表/操作数栈  │  native 方法用     │
└──────────────────────────────────────────────────────────┘

各区域职责与控制参数:

区域私有/共享存什么谁管理出错形态大小参数
程序计数器私有当前线程正在执行的字节码地址JVM唯一不会 OOM 的区域—
虚拟机栈私有栈帧(局部变量表、操作数栈、动态链接、返回地址),每调用一个方法入一个栈帧JVMStackOverflowError(递归过深)、OutOfMemoryError-Xss(如 1MB)
本地方法栈私有native(C/C++)方法调用JVM同上—
堆共享所有对象实例和数组,GC 主战场GCOutOfMemoryError: Java heap space-Xms/-Xmx
方法区/元空间共享类元数据、方法字节码、运行时常量池(即 1.9.3 所述)JVMOutOfMemoryError: Metaspace-XX:MaxMetaspaceSize
直接内存(规范外但重要)—NIO 的 DirectByteBuffer、MMKV 的 mmap 映射应用/框架OutOfMemoryError: Direct buffer memory-XX:MaxDirectMemorySize

堆的内部再分层(GC 视角):

堆(-Xmx)
├── 年轻代
│    ├── Eden(新对象出生地,TLAB 在此内部分线程切分)
│    └── Survivor ×2(Minor GC 后幸存者交替存放)
└── 老年代(熬过多次 GC 的长命对象)

分配极快的原因:对象优先在 TLAB(Thread Local Allocation Buffer,线程私有的小块 Eden)里用"指针碰撞"分配——只是移动一个指针,不需要加锁。

2.4 OS 视角:一个 Java 进程的真实虚拟地址空间

JVM 规范的"运行时数据区"是逻辑划分;它们物理上都落在 OS 进程映像的各种段里。64 位 Linux 上一个运行中的 Java 进程,/proc/<pid>/maps 里大致是这样的:

高地址
┌────────────────────────────────────────────┐
│  内核空间(用户态不可直接访问,共享)             │
├────────────────────────────────────────────┤ 0x7ffd...
│  主线程栈 ↓(默认 8MB,按需增长)               │
│                                            │
│            (地址空间空洞)                    │
│                                            │
│  各线程栈 ↑(pthread_create 为每线程 mmap     │
│            一段,Java 的 -Xss 控制的就是它)    │
├────────────────────────────────────────────┤
│  mmap 映射区(从高到低大致):                  │
│   ├ 共享库:libc.so、libjvm.so(.text 共享)   │
│   ├ 堆:-Xmx 大小 **mmap 预留**,按代分块       │
│   │     commit,真正 touch 才占物理内存        │
│   ├ 元空间 Metaspace(本地内存,动态扩张)       │
│   ├ JIT Code Cache(编译后的机器码)           │
│   ├ DirectByteBuffer / NIO 缓冲区             │
│   └ 应用自己 mmap 的文件(MMKV、日志…)         │
├────────────────────────────────────────────┤
│  brk 堆(C 的 malloc 小块分配起点,             │
│         JVM 内部 C++ 对象也在用)              │
├────────────────────────────────────────────┤
│  .bss  未初始化全局数据                        │
│  .data 已初始化全局数据                        │
│  .text  代码段(java 启动器自身的机器码)        │
└────────────────────────────────────────────┘ 低地址

几个容易误解的点:

  1. Java 堆不是"brk 堆":JVM 启动时用 mmap 一次性预留(reserve) -Xmx 大小的虚拟地址空间,再按需**提交(commit)**分代区域——-Xms 决定初始提交量。所以 -Xmx8g 的进程刚启动 RSS 可能只有几百 MB:虚拟地址空间大 ≠ 物理内存占用大。
  2. 元空间不在 Java 堆里:它也是 mmap 出来的本地内存,和堆平级;所以 -Xmx 再大也不影响类元数据可用量。
  3. 每个 Java 线程都有独立栈:new Thread() 会触发 OS 为其 mmap 一段栈,-Xss 控制的就是这段大小——这就是为什么线程数受内存限制(1000 线程 × 1MB ≈ 1GB 虚拟空间)。

2.5 深入:mmap 与 mmap 映射区

2.4 的布局图里,堆和栈之间有一大片"mmap 映射区",元空间、Code Cache、MMKV 都住在那里。这一节把它讲透——它是理解 MMKV、zygote 共享、Binder 零拷贝的共同基础。

2.5.1 从传统文件 IO 说起:mmap 解决什么问题

读一个文件的传统路径(read() 系统调用):

磁盘 ──DMA──▶ 内核页缓存(Page Cache) ──CPU拷贝──▶ 用户态缓冲区 ──▶ 应用代码
                    第1次拷贝                第2次拷贝
(还有:系统调用陷入内核态 + 上下文切换的开销)

数据要经历两次拷贝、一次内核态切换才能到应用手里。mmap 把这个流程改成了:

磁盘 ──缺页时按需──▶ 内核页缓存 ◀═══════ 应用直接读写(映射的虚拟地址)
                          ↑ 用户态和内核态看到的是同一份物理页,零拷贝

2.5.2 mmap 的原理:它不是"分配内存",而是"建立映射"

mmap 系统调用做的事情,本质上是在进程的虚拟地址空间里登记一段映射关系(内核里叫 VMA,Virtual Memory Area):

mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, offset)
                │
                ▼
进程虚拟地址空间                          内核 Page Cache          磁盘
┌────────────────┐
│ ...             │
├────────────────┤     页表映射(缺页时建立)    ┌──────────────┐
│ 新登记的 VMA     │ ════════════════════════▶ │ 文件的页       │ ◀── 磁盘
│ (虚拟地址区间,   │                           │ (Page Cache)  │
│  对应文件 offset │                           └──────────────┘
│  开始的 len 字节) │
├────────────────┤
│ ...             │
└────────────────┘

关键流程:

  1. mmap 调用本身:只在虚拟地址空间登记一段 VMA,不分配物理内存、不读文件——所以它极快,映射一个 1GB 文件也是微秒级;
  2. 第一次访问映射区间:触发**缺页异常(Page Fault)**→ 内核把对应的文件页从磁盘读入 Page Cache → 建立虚拟地址 → 物理页的页表项;
  3. 之后的访问:就是普通的内存读写,直接命中 Page Cache 里的物理页,没有任何系统调用和拷贝;
  4. 写入:只是改了 Page Cache 里的页(标记为脏页),并不会立即落盘——由内核回写线程延迟刷盘,或显式 msync() 强制刷。这也是"用 mmap 做存储必须自己兜崩溃一致性"的原因(MMKV 用 CRC + 重灌策略兜底)。

2.5.3 mmap 映射区是什么

定义:进程虚拟地址空间里,位于 brk 堆之上、栈之下的那段区域,专门承载各种 mmap 登记的 VMA。 它不是一段"预先划好的内存",而是内核按需在这片区间里逐段分配的空间。

实际运行中,映射区里挤着这些东西(回看 2.4 的图):

映射内容类型例子
共享库的代码/数据段文件映射 + 私有(COW)libc.so、libjvm.so——所有进程共享同一份物理页
JVM 堆匿名映射(大块 reserve+commit)-Xmx8g 的那片空间
元空间 Metaspace匿名映射类元数据
JIT Code Cache匿名映射(可执行)JIT 编译出的机器码
线程栈匿名映射每个线程 -Xss 大小
文件映射文件映射 + 共享MMKV 文件、MappedByteBuffer
匿名大块内存匿名映射glibc malloc 的大块分配(>128KB 走 mmap)

2.5.4 mmap 的四种模式

mmap 有两个关键标志位,组合出四种行为:

文件映射(有 fd)匿名映射(无 fd)
MAP_SHARED(共享)多进程映射同一文件 → 共享同一份物理页,互相对彼此的修改可见,且会写回磁盘fork 后父子共享(配合 COW 用于 IPC)
MAP_PRIVATE(私有)读时共享文件页,写时触发 COW 复制私有副本,改动不写回文件zygote fork 共享框架类用的就是它:App 进程读框架类 = 读共享页;一旦要改(极少发生)才复制

两种映射的典型用途:

  • 文件映射(MAP_SHARED):MMKV 把 KV 文件 mmap 进来 → 读写 key-value = 读写内存,还天然"持久化"(落盘交给内核回写);
  • 匿名映射(MAP_PRIVATE)+ COW:Android 的 zygote 预加载框架类后 fork 出 App 进程,父子进程共享所有页;某个进程要写某页时内核才复制该页(Copy-On-Write)——这就是"100 个 App 进程共享一份 framework 类元数据"的机制。

2.5.5 Java 中如何使用 mmap

FileChannel channel = FileChannel.open(path, READ, WRITE);
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, channel.size());

buffer.put(0, (byte) 42);   // 直接当内存读写文件
// 注意:没有"unmap"的显式 API,依赖 GC + Cleaner 回收映射
  • FileChannel.map() 返回的 MappedByteBuffer 底层就是 mmap;
  • MMKV 的 C++ 层直接调 mmap(),Java 层再把这段内存封装成读写 API——它比 MappedByteBuffer 更彻底(多进程安全、文件可增长)。

2.5.6 mmap 的优势与代价

优势:

  1. 零拷贝:用户态直接访问 Page Cache,省去两次 CPU 拷贝和系统调用开销;
  2. 按需加载:映射 1GB 文件不会立即占 1GB 内存,访问到哪页才加载哪页(天然适合大文件、随机访问);
  3. 多进程共享:MAP_SHARED 让多个进程共享同一份物理页(MMKV 多进程共享 KV 的基础);
  4. 崩溃不丢已刷数据:进程崩溃不影响 Page Cache,内核照样回写——比"自己 write 的用户缓冲区"更可靠;
  5. 代码统一:把"文件 IO"变成"内存访问",代码里不再需要 read/write 缓冲区管理。

代价与坑:

  1. 写回时机不可控:脏页由内核延迟刷盘,掉电时可能丢最后几毫秒的数据 → 需要显式 msync()(有开销);
  2. 缺页抖动:首次访问或页被换出后再访问都会陷入内核,随机访问大文件时可能比顺序 read 更慢;
  3. SIGBUS 风险:映射后文件被截短,再访问越界部分进程直接收到 SIGBUS 信号(MMKV 处理文件损坏就要考虑这个);
  4. 小文件不划算:建立 VMA、缺页的固定开销,对小文件反而不如一次 read;
  5. Page Cache 由内核管理:无法主动控制哪页驻留内存(没有 Java 层的 pin 语义)。

2.5.7 串回主线

前面的结论mmap 层面的解释
MMKV 为什么快mmap 文件映射:读写 KV = 读写内存,省两次拷贝 + 系统调用;写回交给内核
MMKV 为什么"敢"落盘 Parcel 字节mmap + CRC 校验 + KV 记录隔离,补上了 mmap "写回不可控、损坏难察觉"的短板
100 个 App 共享一份框架类zygote 预加载 + fork + MAP_PRIVATE 匿名映射 + COW
Binder "一次拷贝"接收进程在 mmap 区预留一块接收缓冲区,发送方 copy_from_user 直接写入对方映射的物理页——省掉"内核→用户态"的第二次拷贝(严格说是"零拷贝的变体":仍有用户态→内核的一次拷贝)
元空间/Code Cache/线程栈的位置全部是 mmap 映射区的匿名映射(2.4 布局图的来源)

2.6 与 C 语言进程虚拟地址空间的对比

先看经典的 C 进程布局——你会发现骨架和上面一模一样:

高地址
┌──────────────────────┐
│ 内核空间               │
├──────────────────────┤
│ 栈 ↓(局部变量)        │
│   (空洞)             │
│ 堆 ↑(malloc/free)   │
├──────────────────────┤
│ .bss / .data          │
│ .text(机器码)        │
└──────────────────────┘
低地址

结论先行:C 进程和 Java 进程跑在完全相同的 OS 虚拟内存模型上——JVM 没有发明新机制,只是在同一套骨架上叠加了自己的管理层。 具体差异:

维度C 进程Java(JVM)进程
地基OS 虚拟地址空间:text/data/bss/heap/mmap/stack/内核相同——JVM 也是普通进程,五段布局一个不少
代码的形态机器码在 .text 段,加载后 CPU 直接执行字节码在元空间(是数据!),运行时 JIT 编译成机器码放入 Code Cache(mmap 区)——"代码"变成了被管理的数据
堆的分配方式malloc/free 手动管理(brk/mmap 系统调用),忘了 free 就泄漏,double free 直接崩溃JVM 预留+提交大块堆,TLAB 指针碰撞分配,GC 分代自动回收——分配更快,但代价是 GC 停顿与调优复杂度
数据能放哪栈、堆、静态区都能放数据结构:局部 struct 在栈上,malloc 在堆,全局变量在 .data/.bss对象一律在堆上,栈上只存引用;"对象在栈上"只是 JIT 逃逸分析+标量替换的优化结果,程序员不可见
内存访问方式指针可运算(p+1)、可强转、可指向任意地址;越界 = 未定义行为/段错误引用受控:不可运算、不可伪造;越界抛 ArrayIndexOutOfBoundsException、空引用抛 NullPointerException——安全性是语言层强制的,不是 OS 层的
栈的管理主线程栈由 OS 分配;递归过深直接段错误(未定义行为)每线程独立 mmap 栈,-Xss 可调;递归过深抛受控的 StackOverflowError
静态/全局数据.data(已初始化)、.bss(未初始化)static 字段存 Java 堆(JDK 7+);类元数据在元空间——"全局数据"被拆成了两部分
内存回收无自动回收(靠程序员/工具:valgrind、ASan)GC 自动回收,分代假设(大部分对象朝生夕死)驱动整个堆设计
典型故障段错误、内存泄漏、悬空指针、缓冲区溢出(安全漏洞温床)OOM(各区域各异)、GC 停顿、StackOverflowError——崩溃变成"可控的异常"

一张图总结两者关系:

C 进程:   OS 骨架(text/data/heap/stack)→ 程序员直接使用
                          │
Java 进程:OS 骨架        → JVM 接管大部分区域,再划分:
                            ├ brk/mmap ──▶ Java 堆(GC 管理,分代)
                            ├ mmap    ──▶ 元空间(类元数据)
                            ├ mmap    ──▶ Code Cache(JIT 产物)
                            ├ mmap    ──▶ 线程栈(-Xss)
                            └ .text   ──▶ 只剩 JVM 启动器自己

补充一:.text 机器码是什么时候加载进内存的?

结论:启动时只做"映射",不读入内容;CPU 第一次执行到哪一页,那一页才真正进入物理内存——按需分页,和类加载的"懒加载"一模一样。

execve(启动一个程序)时内核做的事:

1. 读取 ELF 文件头,解析出各段的属性(.text: 只读可执行)
2. 为 .text/.data/.bss/堆/栈 在虚拟地址空间登记 VMA(只是"记账",不读磁盘!)
3. 把 CPU 的指令指针 RIP 设置为 ELF 的入口地址(_start → __libc_start_main → main)
4. 返回用户态,开始执行

注意第 2 步:此刻 .text 的内容还在磁盘上,物理内存里一个字节的指令都没有。真正的加载发生在执行中:

CPU 执行 main 第一条指令
   → RIP 指向 .text 的虚拟地址,页表里没有映射
   → 缺页异常(Page Fault),陷入内核
   → 内核从 ELF 文件读入该 4KB 页到 Page Cache,建立页表映射
   → 回到用户态,重新执行那条指令 → 成功
   → 之后执行到"下一页"时,再次缺页、再加载一页……

所以一个 50MB 的程序,启动时可能只加载了不到 1MB 的代码页(入口路径上的那些),其余的 .text 终其一生都可能没被访问过。共享库(.so)同理:动态链接器 ld.so 启动时把依赖库 mmap 进来,配合 PLT/延迟绑定,函数第一次被调用时才真正解析和加载。

呼应 1.9.3:类的"按需加载"、JIT 的"热点才编译"、mmap 的"缺页才读文件"——按需(lazy)是贯穿整个系统的统一设计哲学,因为"提前准备好用不到的东西"在成本上永远不划算。

补充二:CPU 如何通过虚拟地址访问到真实的物理地址?

CPU 每次取指令时,RIP 里存的是虚拟地址。从虚拟地址到物理地址、再到真正的指令执行,完整链路如下:

                 取指令:RIP = 0x00007f8a_12345670(虚拟地址)
                        │
                        ▼
        ┌──── 拆分 ────┴────────────────────────────┐
        │ 页目录索引 │ 页表索引 │ ... │ 页内偏移        │
        └───────────┬──────────────────────┬───────┘
                    ▼                      │
        ┌─────────────────────┐            │
        │ ① 查 TLB(快表)      │            │ 页内偏移
        │ 缓存最近用过的映射     │            │ (低 12 位,
        └──────┬───────┬──────┘            │  直接透传)
          命中 │       │ 未命中              │
               │       ▼                   │
               │  ② 页表遍历(Page Table Walk)│
               │  x86-64 四级页表:            │
               │  PML4 → PDPT → PD → PT      │
               │  (内存中的页表,由内核维护)    │
               │       │                     │
               │       ▼                     │
               │  ③ 得到物理页帧号,回填 TLB    │
               │       │                     │
               ▼       ▼                     ▼
        物理地址 PA = 物理页帧号 × 4096 + 页内偏移
                        │
                        ▼
              ④ 从 L1 I-Cache / 内存取指令 → 译码 → 执行

逐步解释:

  1. TLB(Translation Lookaside Buffer):CPU 内部缓存"虚拟页号 → 物理页帧号"的硬件表。绝大多数取指都能在这里一步命中(命中率 >99%),这是虚拟内存机制不拖慢执行的关键;
  2. 页表遍历(Page Walk):TLB 未命中时,MMU 硬件自动走多级页表(x86-64 为 4 级,每级 9 位索引)。页表本身也存在内存里、由内核维护——这次遍历还要再查 4 次内存,所以 TLB miss 代价不小(大页 Huge Page 就是为此而生:一页 2MB,TLB 覆盖范围翻倍);
  3. 缺页异常:如果页表项显示该页不存在(尚未加载/被换出),CPU 陷入内核,走"补充一"的按需加载流程,然后重试;
  4. 权限检查:页表项带着权限位。.text 的映射是只读 + 可执行——试图写 .text 会段错误;数据页带 NX(不可执行)位——往数据里塞指令再跳过去执行(经典的缓冲区溢出攻击)会被硬件直接拦截。"代码不可改、数据不可执行"是 MMU 页表在硬件层强制的。

与 Java 的对照——Java 进程里 CPU 取指的对象其实是"两套机器码":

存放位置加载方式谁生成
JVM 本体 + 解释器.text 段 / libjvm.so 的映射启动时映射,按需分页C++ 编译期
JIT 编译产物Code Cache(匿名映射、可执行)生成即写入内存运行时 JIT

解释器执行字节码时,RIP 始终在 libjvm.so 的 .text 里循环跑;热点方法被 JIT 编译后,RIP 才跳进 Code Cache 里执行生成的机器码。对 CPU 和 MMU 来说两者没有任何区别——都是"虚拟地址 → TLB/页表 → 物理地址 → 取指",mprotect 标记可执行后代码 Cache 与 .text 在硬件眼里地位相同。

Android 上同理:AOT 编译产物(.oat 文件里的机器码)由 ART 启动时 mmap 进虚拟地址空间,缺页时按需加载——和 .text 的加载方式完全一致。

2.7 Android(ART)上的差异

Android 的内存模型骨架同 Linux,但有两处特色:

  1. 进程由 zygote fork 而来:zygote 启动时预加载了框架类(含 Parcel)和常用资源;fork 出的 App 进程共享这些内存页(写时复制 COW)——这就是每个 App"天生"就有 android.os.Parcel 可用、且启动快的内存层原因;
  2. 堆的构成不同:ART 堆分为 Zygote Space / Allocation Space / Large Object Space(LOS,大对象如 Bitmap);Java 堆上限由设备厂商按内存规格设定(largeHeap 清单属性可申请更大);
  3. native 堆独立:Bitmap 像素、Parcel 缓冲区等走 malloc 的 native 堆,不受 Java 堆上限管辖(通过 NativeAllocationRegistry 与 Java 对象生命周期挂钩)。

2.8 串回序列化主线

本章为前面的所有结论补上了"物理地址"层面的证据:

前面的结论OS/内存模型层解释
内存中的对象不能直接传输/存储对象地址是本进程虚拟地址空间内的地址,页表映射、空间隔离使它离开进程即失效(第 2 层隔离机制)
Binder 传输"一次拷贝"内核在两个进程的虚拟空间之间直接搬运内存页数据,不经用户态中转
MMKV 高性能用 mmap 把文件映射进进程虚拟地址空间(mmap 区),读写文件变成了读写内存,还省去了传统 IO 的内核↔用户态拷贝
反射可访问类元数据对象头类型指针 → 元空间中的类元数据(2.3 表中"方法区"一行)
-Xmx8g 不等于占 8g 物理reserve(预留虚拟地址)≠ commit(提交)≠ touch(占物理页)——OS 按需调页机制

三、字节流、字节码、二进制流:概念与区别

2.1 字节流(byte stream)

定义:按顺序排列的一串字节(8-bit 的 0/1),强调按顺序逐字节读写的访问方式。

[01101001] [11100001] [00000000] [10101010] → ...
  第0字节    第1字节    第2字节    第3字节

为什么字节是公共语言:同一串字节在不同视角下含义不同(54 6F 6D 可以是 "Tom"、可以是整数、可以是像素),但字节本身没有歧义,磁盘、网卡、管道天然只认字节序列。

"流"是抽象接口:Java 用 InputStream / OutputStream 统一了"按顺序读写字节"的行为,同一套代码可以接磁盘文件、Socket、内存、键盘:

InputStream in = new FileInputStream("a.txt");   // 来自磁盘
InputStream in = socket.getInputStream();        // 来自网络
InputStream in = new ByteArrayInputStream(buf);  // 来自内存

字节流 vs 字符流:

字节流字符流
Java 基类InputStream / OutputStreamReader / Writer
单位8-bit 字节字符(带编码转换)
适用一切二进制:图片、音频、序列化数据一定是文本:txt、json、xml

流的"无结构"特性:字节流没有消息边界和类型概念,实际使用要在其上叠加结构——长度前缀、分隔符、协议头、checksum,或用装饰器流(BufferedInputStream、GZIPOutputStream、ObjectOutputStream)层层包装。

2.2 二进制流(binary stream)

定义:不是 Java 官方术语,是习惯叫法,强调数据不做任何文本层面的转换,原样搬运。

它与"文本流"对立。这个区分来自 C 语言的文件打开模式:

FILE *f = fopen("a.txt", "r");    // 文本模式:Windows 会把 \r\n 自动翻译成 \n
FILE *f = fopen("a.bin", "rb");   // 二进制模式:字节原样进、原样出

关键结论:字节流天生就是二进制流——它本来就不认识"字符",字符是上层自己解释出来的。日常语境下两个词基本可以互换;"二进制流"强调"不做文本转换","字节流"强调"以 8 bit 为读写单位"。

2.3 字节码(bytecode)

定义:Java 源码经 javac 编译后得到的中间指令集,既不是源码、也不是某个 CPU 的机器码,而是专门给 JVM 执行的一套指令。

名字由来:指令集中每条操作码(opcode)固定占 1 个字节,理论上最多 256 条指令。

User.java ──javac──▶ User.class(字节码)──JVM 解释/JIT──▶ 机器码

跨平台的本质:字节码是"面向 JVM 这个虚拟 CPU"的机器码;Java 的跨平台不是源码跨平台,而是字节码 + JVM 组合带来的。

字节码的样子(javap -c 反汇编):

public int add(int, int);
  Code:
     0: iload_1        // 把第1个 int 参数压栈
     1: iload_2        // 把第2个 int 参数压栈
     2: iadd           // 弹出两个数相加,结果压栈
     3: ireturn        // 返回栈顶的 int

关键特征——基于栈:JVM 字节码通过操作数栈完成计算(iload 压栈、iadd 出栈相加),没有寄存器概念,因此不依赖具体 CPU。对比:Android 的 Dalvik/ART 字节码(.dex)是基于寄存器的,指令更长但执行效率更高。

.class 文件结构(本身就是一种字节流):

┌─────────────────────────────┐
│ 魔数 0xCAFEBABE              │ ← JVM 加载前校验
│ 版本号(major.minor)         │ ← 52.0 = Java 8
│ 常量池(类名、方法名、字符串…) │ ← 字节码里所有符号靠索引指向这里
│ 访问标志 / 字段表 / 方法表     │
│   └ Code 属性 ── 真正的字节码指令 │
└─────────────────────────────┘

字节码的三大价值:

  1. 跨平台:一份 .class 跑遍所有有 JVM 的平台;
  2. JIT 优化:先解释执行(启动快),热点代码 JIT 编译成优化机器码(运行快);
  3. 可二次加工:ASM/CGLIB/Byte Buddy 生成或修改字节码(AOP、动态代理)、ProGuard/R8 混淆、热修复、静态分析。

Android 上的链条:

.java ──javac──▶ .class(JVM字节码,栈式)──d8/R8──▶ classes.dex(Dalvik字节码,寄存器式)──▶ ART 执行

APK 里是 .dex 而不是 .class;Kotlin 同样先编译成 .class 再转 dex。

2.4 三者区别总表

概念是什么单位/层次典型代表
字节流按字节顺序读写的数据通道(强调载体/访问方式)8-bit 字节InputStream/OutputStream
二进制流不做文本转换的原样字节搬运(强调无字符加工)8-bit 字节C 的 "rb" 模式;与文本流对立
字节码JVM 的指令集,.class 的核心内容(强调内容/指令)1 字节 opcode 指令.class、.dex

一句话:字节码是"内容/指令",字节流是"载体"——一个 .class 文件通过网络传输时,物理上是字节流,逻辑内容上是字节码。严格往下还有 bit 流(按位操作、不保证字节对齐,如哈夫曼编码)。


四、Parcel:概念、原理与实现

3.1 概念

android.os.Parcel 是 Android 独有的类(属于 AOSP Framework,Java JDK 中不存在),用于进程间通信(IPC):配合 Binder 机制,把对象序列化成一块连续内存,跨进程传递。AIDL 生成的所有 Stub/Proxy 代码底层全靠它。

3.2 设计定位:专用序列化

序列化是个谱系,Parcel 位于"专用性"的最左端:

专用性 ◀──────────────────────────────▶ 通用性

Parcel          JDK Serializable       JSON / Protobuf
  │                  │                       │
  └─ 仅限:同一设备、  └─ 仅限:JVM 内、        └─ 任何平台、
     同一内核、内存中     可信数据                 任何语言、跨版本
     的进程间传递

它只为一个场景做极限优化:同一台设备上、通过 Binder 内核驱动、在两个进程的内存之间搬运数据,为此放弃了其他所有能力。

3.3 实现原理

Java 层只是薄壳,核心在 native:Parcel 的 writeInt/writeString 等方法都是 JNI 调用,真正实现在 C++ 层(frameworks/native/libs/binder/Parcel.cpp):

  1. 连续内存缓冲区:Parcel.obtain() 从池中取一个 Parcel 对象,内部持有一块可扩容的连续内存;所有 writeXxx 就是把数据按约定格式平铺进这块内存;
  2. 格式约定:
    • 基本类型按固定长度直接写入(writeInt 4 字节);
    • String 写入长度 + UTF-16 编码字节;
    • 复杂对象递归调用其 writeToParcel();
    • 内部有 4 字节对齐规则;
    • 所有结构按写入位置约定,无字段名、无类型标签、无 schema;
  3. Binder 传输:进程 A 把 Parcel 缓冲区交给 Binder 驱动,驱动把数据拷贝到进程 B 映射的内存中(一次拷贝),进程 B 从 Parcel 中按相同顺序 readXxx 读出;
  4. 池化回收:用完调用 recycle() 归还对象池,避免频繁分配内存;Parcel 不是线程安全的,不要多线程共享。

性能高的原因:

  • 无反射:字段读写顺序由开发者手写(或 @Parcelize 生成);
  • 无元数据:不写类名、字段名、schema;
  • 直接内存拷贝:经 Binder 一次拷贝直达对端,不经过中间字节流。

3.4 为什么 Parcel 不能持久化和跨网络传输

Parcel 确实是序列化,但它牺牲了通用序列化必需的三大支柱:

不能持久化的原因

  1. 格式没有稳定性承诺:读写格式是 AOSP 实现细节,可能随 Android 版本变化;官方文档明确说明 Parcel 不是通用序列化机制,绝不能用于持久化存储;
  2. 没有版本兼容机制:协议是"按位置约定",类加字段后旧数据全部错位,且静默地坏(不报错,读到垃圾数据);
  3. 不校验、无自描述:连"这是什么类"的信息都没有,无 checksum、无 schema 校验,落盘数据损坏时无任何防护。

不能跨网络传输的原因

  1. 破坏"两端环境一致"假设:依赖同 Android 版本、同架构、Binder 内核驱动参与;writeBinder/writeFileDescriptor 写入的是只在本地内核有意义的句柄;
  2. 安全攻击面:解析端按"数据来自可信对端进程"设计,放到网络上等于把解析不可信数据的接口暴露给全网(长度不匹配、恶意构造、越界读);
  3. 平台差异:字节序、对齐在异构设备上直接导致数值错误。

3.5 反例印证:为什么 MMKV 能用 Parcel?

MMKV 并没有推翻规则,而是改写了风险模型:

层用什么说明
核心 KV 编码Protobuf基础类型(int/string/bool…)底层是 MMKV 自己 C++ 实现的 Protobuf 变体
对象存储ParcelencodeParcelable() 调用 writeToParcel() 得到 byte[] 再存储;读取用传入的 CREATOR 反解

它"敢"这么做的条件:

  1. 写入方和读取方是同一个类(writeToParcel 与 CREATOR 在同一 APK 里一起编译升级)——相当于把"跨时间的持久化"退化成"本 App 内部、跨时间点的 IPC";
  2. 缓存语义兜底:解析失败返回 null,等价于"缓存未命中"而非"核心数据损坏";
  3. 文件层补充防护:MMKV 加了 CRC-32 校验(补 Parcel 没有的完整性检查),KV 结构把每个值隔离成独立记录,坏一条只丢一个 key。

实践建议:

  • ✅ encodeParcelable 适合存缓存类对象(丢了能重新拉取);
  • ⚠️ Parcelable 类升级时必须保持读写顺序兼容(新字段加末尾 + 读取时判 null);
  • ⚠️ 关键数据(订单、草稿)改用 JSON/Protobuf 编码后 encode;
  • MMKV 核心编码选 Protobuf 而非 Parcel,本身就是"Parcel 不适合做存储协议"的注脚。

总结:Parcel = "进程间的 memcpy 加速版"。 它用通用性换速度,而通用性正是持久化和网络传输不可或缺的部分。


五、Serializable:概念、原理与实现

4.1 概念

java.io.Serializable 是 JDK 标准库提供的序列化标记接口(无任何方法,仅作声明),配合 ObjectOutputStream / ObjectInputStream 实现基于反射的通用对象序列化,可用于持久化(文件)和网络传输。

4.2 基本用法

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    private transient String password; // 不参与序列化

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();      // 先按默认规则写字段
        out.writeObject(encrypt(password)); // 可追加自定义数据
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        password = decrypt((String) in.readObject());
    }
}

// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.bin"));
oos.writeObject(user);
oos.close();

// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.bin"));
User user = (User) ois.readObject();
ois.close();

4.3 实现原理

核心机制:反射 + 对象图遍历 + 类元数据自描述。

序列化时(ObjectOutputStream.writeObject):

  1. 写入流头(magic number AC ED + 版本号);
  2. 通过反射获取对象的类信息,写入类元数据:类全名、serialVersionUID、字段描述列表(字段名 + 类型签名)——注意:不含方法字节码;
  3. 递归遍历对象图:字段若是对象引用,继续序列化引用的对象;通过 ObjectStreamClass 的引用表处理循环引用(同一对象只写一次,后续写引用编号);
  4. 逐字段写出值(基本类型直接写,对象类型递归);
  5. 若类自定义了 writeObject,优先执行(defaultWriteObject 负责默认部分);
  6. transient 和 static 字段不写入。

反序列化时(ObjectInputStream.readObject):

  1. 读流头、读类元数据;
  2. 用类名从当前 classpath 加载类(Class.forName)——数据传过去了,但代码必须事先部署在两端,找不到就抛 ClassNotFoundException;
  3. 校验加载到的类的 serialVersionUID 与流中是否一致,不一致抛 InvalidClassException;
  4. 反射创建实例(不走构造函数!);
  5. 按字段描述从流中读值,反射塞进对应字段;
  6. 若类自定义了 readObject,执行它。

流的结构示意:

[流头 AC ED 00 05] [类元数据: 类名+serialVersionUID+字段描述] [字段值1] [字段值2] ... 

4.4 关键细节

  1. serialVersionUID:类的"身份证",用于版本校验。不显式声明时 JVM 会根据类结构自动生成——但类有任何改动(哪怕加个方法)都会变化,导致旧数据无法读取。最佳实践:显式声明 private static final long serialVersionUID = 1L;。
  2. 版本兼容规则(声明固定 serialVersionUID 后):
    • 新增字段:兼容,旧数据读出后新字段为默认值;
    • 删除字段:兼容,流中多余数据被忽略;
    • 改字段类型:不兼容;
    • 但规则脆弱,仅建议用于简单演进。
  3. transient:修饰不参与序列化的字段(密码、缓存、句柄);反序列化后该字段是默认值(null/0),可在 readObject 中恢复。
  4. 不走构造函数:反序列化直接分配内存 + 反射塞值,构造函数中的初始化逻辑不会执行——这是隐藏 bug 的高发点(如字段依赖构造时初始化的非序列化成员)。
  5. 静态字段不序列化:static 属于类不属于实例。
  6. 敏感字段必须 transient:否则密码明文进入字节流。

4.5 安全红线

永远不要用 ObjectInputStream 反序列化不可信来源的数据。 JDK 原生序列化是真实的重大漏洞类型(如 Apache Commons Collections 反序列化 RCE):攻击者构造恶意"对象图"(gadget chain),readObject 过程中触发任意代码执行。业界规范普遍禁止对网络输入使用 JDK 原生序列化,跨网络通信优先用 JSON/Protobuf。

4.6 性能问题与原因

  • 反射开销:获取字段、逐个 Field.set;
  • 元数据冗余:每个对象都要写类名全路径 + 字段描述;
  • 对象图遍历:引用追踪、循环引用检测都有额外成本;
  • 对比:Parcelable(无反射、无元数据)在 Android 上快数倍、体积小数倍。

六、Parcel 与 Serializable 的区别

5.1 总对比表

维度Parcelable / ParcelSerializable
归属Android Framework(android.os),JDK 没有Java JDK 标准(java.io)
实现方式手写读写逻辑(无反射),或 @Parcelize 自动生成反射自动遍历对象图
元数据不写类名、字段名、schema写入类全名、serialVersionUID、字段描述
格式按写入位置约定的私有二进制格式自描述流(带类元数据)
性能快数倍(纯内存操作 + 一次拷贝)慢(反射 + 元数据 + 对象图遍历)
体积小大
使用场景仅限内存中传输:Binder/AIDL、Intent、Bundle持久化(文件)、网络传输(可信环境)、深拷贝
能否落盘❌ 官方明确禁止✅ 可以
能否走网络❌⚠️ 技术可行,安全上禁止用于不可信数据
版本兼容❌ 无机制,字段变更即错位⚠️ 靠 serialVersionUID,规则脆弱但存在
循环引用❌ 不处理(需自己避免)✅ 自动处理
构造函数反序列化时调用(CREATOR.createFromParcel → 你的构造逻辑)反序列化时不调用(反射直接分配)
自定义钩子就是自己写的 writeToParcel/构造writeObject/readObject/readResolve 等
典型代价维护读写顺序一致的样板代码性能 + 安全风险

5.2 设计哲学的差异

两者代表了序列化设计的两个极端:

Parcel:牺牲"通用性"换"速度"
  - 假设两端同设备、同内核、代码同版本
  - 所以敢省掉一切元数据和校验
  - 快,但只能活在一个狭窄场景里

Serializable:牺牲"速度"换"通用性"
  - 目标是 JVM 内任何场景:文件、网络、深拷贝
  - 所以必须带自描述元数据、版本校验
  - 通用,但慢且有安全隐患

5.3 一个直观的对照

同样是 User(name, age),两者产出的数据结构:

Serializable 流:
[流头][类名"com.example.User"][serialVersionUID=1][字段描述: name:String, age:int]["Tom"][18]

Parcel 数据:
["Tom"的UTF-16字节][18的4字节小端]     ← 就这么多,没有任何"这是什么"的信息

Serializable 的字节流自己解释自己(所以能落盘、能跨版本读);Parcel 的数据离开约定好顺序的代码就毫无意义(所以只能配合 Binder 在受控两端使用)。

5.4 选型决策

需要跨进程(Binder/AIDL/Intent/Bundle)?
  └─ 是 → Parcelable(性能必须)
需要落盘或走网络?
  ├─ 跨语言/跨服务/版本演进频繁 → Protobuf
  ├─ 需要人类可读/调试方便 → JSON
  └─ 仅 JVM 内、数据可信、图省事 → Serializable
存 KV 缓存(MMKV)?
  └─ 缓存类对象可 encodeParcelable;关键数据用 JSON/Protobuf 编码后存

附:本文涉及的核心口诀

  1. 序列化传的是"这个对象此刻的样子","它会做什么"由两端共同的类定义决定。
  2. 内存中的对象不能直接传输存储,因为:引用是进程私有的、布局是运行时私有的、环境是活的、边界是隔离的。
  3. 字节流是载体,字节码是内容;字节流天生是二进制流;真正的对立面是文本流。
  4. Parcel = 进程间的 memcpy 加速版:用通用性换速度,而通用性正是持久化和网络传输不可或缺的部分。
  5. MMKV 能用 Parcel,是因为它把使用场景裁剪到了 Parcel 通用性覆盖的地方:同 App、同设备、缓存语义 + CRC 兜底。
  6. Serializable 通用但慢且危险:反射是慢的根源,"反序列化即分配 + 不走构造 + 可触发任意代码"是危险的根源。