此文档由AI生成
本文档整理自一系列关于 Android/Java 序列化机制的问答,涵盖:序列化原理与实现、字节流/字节码/二进制流、Parcel、Serializable 及其对比。
目录
- 序列化:概念、原理与实现
- Java 进程的虚拟内存模型
- 字节流、字节码、二进制流:概念与区别
- Parcel:概念、原理与实现
- Serializable:概念、原理与实现
- 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 序列化的两大用途
- 持久化:对象 → 磁盘(保存状态、缓存)
- 传输:对象 → 网络/进程间(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 实践要点
- 深浅拷贝:序列化再反序列化一遍,天然实现深拷贝(注意性能)。
- transient:标记不需要序列化的字段——密码、缓存、连接句柄。
- 版本兼容:
Serializable靠serialVersionUID,规则脆弱;- Protobuf 靠字段编号,永远不要复用已使用的编号;
- JSON 按"缺失字段给默认值"的宽容策略解析。
- 安全红线:永远不要反序列化不可信来源的 JDK 原生序列化数据(
ObjectInputStream.readObject)。 - Android 选型口诀:
- Intent / Bundle / AIDL 传数据 →
Parcelable; - SharedPreferences / 文件 / 网络 → JSON 或 Protobuf;
- 数据类用
@Parcelize避免手写样板代码。
- Intent / Bundle / AIDL 传数据 →
1.8 补充:对象中的"函数"如何序列化?
答案:通常不序列化。 序列化只针对"状态",不针对"行为":
- 一个对象 = 状态(实例字段,存在堆里)+ 行为(方法,存在类的定义里,所有实例共享一份);
- 序列化协议传输的是对象快照(数据),代码是部署问题,不是序列化问题;
Serializable流里只写"类名 + 字段描述 + 字段值",不含方法字节码;反序列化端从自己的 classpath 加载类;- JSON 直接忽略方法;JavaScript 的
JSON.stringify同样丢弃函数。
如果确实需要"传输行为",业界做法:
- RPC:两端各自部署方法代码,网络上只传"接口名 + 方法名 + 参数值";
- 规则引擎/DSL:把逻辑降级成数据(SQL、SpEL、JSON 规则),远端解释执行;
- 动态加载代码:单独传输
.class/jar/dex,用 ClassLoader 加载(OSGi、热修复)——这是代码分发,与序列化是两个机制,且有严重安全隐患; - 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 对象 + 元空间中的类元数据":
- 类加载时,JVM 把
.class文件解析成运行时类元数据结构,存入方法区(Java 8 后为元空间 Metaspace,见 1.9.3); - 同时在 Java 堆上创建一个
java.lang.Class对象,作为这些元数据的"入口句柄"——每个类在运行时有且只有一个 Class 对象; getClass()、Xxx.class、Class.forName("...")三种方式拿到的都是这个 Class 对象;getDeclaredFields()等调用,本质是 JNI/本地方法去读元空间里的字段表;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 位,开启压缩指针):
- 对象头(Header,12 字节):
- Mark Word(8 字节):哈希码、GC 分代年龄、锁标志位( synchronized 优化就靠它);
- 类型指针(4 字节,压缩后):指向元空间中的类元数据——这就是
getClass()和反射能工作的物理基础; - 数组对象额外多 4 字节长度字段。
- 实例数据(Instance Data):各字段按类型写入——引用 4 字节(压缩指针)、
int4 字节、long/double8 字节、boolean1 字节;字段排列有重排序规则(相同宽度聚集,父类字段在前); - 对齐填充(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 的区域 | — |
| 虚拟机栈 | 私有 | 栈帧(局部变量表、操作数栈、动态链接、返回地址),每调用一个方法入一个栈帧 | JVM | StackOverflowError(递归过深)、OutOfMemoryError | -Xss(如 1MB) |
| 本地方法栈 | 私有 | native(C/C++)方法调用 | JVM | 同上 | — |
| 堆 | 共享 | 所有对象实例和数组,GC 主战场 | GC | OutOfMemoryError: Java heap space | -Xms/-Xmx |
| 方法区/元空间 | 共享 | 类元数据、方法字节码、运行时常量池(即 1.9.3 所述) | JVM | OutOfMemoryError: 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 启动器自身的机器码) │
└────────────────────────────────────────────┘ 低地址
几个容易误解的点:
- Java 堆不是"brk 堆":JVM 启动时用
mmap一次性预留(reserve)-Xmx大小的虚拟地址空间,再按需**提交(commit)**分代区域——-Xms决定初始提交量。所以-Xmx8g的进程刚启动 RSS 可能只有几百 MB:虚拟地址空间大 ≠ 物理内存占用大。 - 元空间不在 Java 堆里:它也是 mmap 出来的本地内存,和堆平级;所以
-Xmx再大也不影响类元数据可用量。 - 每个 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 字节) │
├────────────────┤
│ ... │
└────────────────┘
关键流程:
- mmap 调用本身:只在虚拟地址空间登记一段 VMA,不分配物理内存、不读文件——所以它极快,映射一个 1GB 文件也是微秒级;
- 第一次访问映射区间:触发**缺页异常(Page Fault)**→ 内核把对应的文件页从磁盘读入 Page Cache → 建立虚拟地址 → 物理页的页表项;
- 之后的访问:就是普通的内存读写,直接命中 Page Cache 里的物理页,没有任何系统调用和拷贝;
- 写入:只是改了 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 的优势与代价
优势:
- 零拷贝:用户态直接访问 Page Cache,省去两次 CPU 拷贝和系统调用开销;
- 按需加载:映射 1GB 文件不会立即占 1GB 内存,访问到哪页才加载哪页(天然适合大文件、随机访问);
- 多进程共享:MAP_SHARED 让多个进程共享同一份物理页(MMKV 多进程共享 KV 的基础);
- 崩溃不丢已刷数据:进程崩溃不影响 Page Cache,内核照样回写——比"自己 write 的用户缓冲区"更可靠;
- 代码统一:把"文件 IO"变成"内存访问",代码里不再需要 read/write 缓冲区管理。
代价与坑:
- 写回时机不可控:脏页由内核延迟刷盘,掉电时可能丢最后几毫秒的数据 → 需要显式
msync()(有开销); - 缺页抖动:首次访问或页被换出后再访问都会陷入内核,随机访问大文件时可能比顺序
read更慢; - SIGBUS 风险:映射后文件被截短,再访问越界部分进程直接收到 SIGBUS 信号(MMKV 处理文件损坏就要考虑这个);
- 小文件不划算:建立 VMA、缺页的固定开销,对小文件反而不如一次
read; - 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 / 内存取指令 → 译码 → 执行
逐步解释:
- TLB(Translation Lookaside Buffer):CPU 内部缓存"虚拟页号 → 物理页帧号"的硬件表。绝大多数取指都能在这里一步命中(命中率 >99%),这是虚拟内存机制不拖慢执行的关键;
- 页表遍历(Page Walk):TLB 未命中时,MMU 硬件自动走多级页表(x86-64 为 4 级,每级 9 位索引)。页表本身也存在内存里、由内核维护——这次遍历还要再查 4 次内存,所以 TLB miss 代价不小(大页 Huge Page 就是为此而生:一页 2MB,TLB 覆盖范围翻倍);
- 缺页异常:如果页表项显示该页不存在(尚未加载/被换出),CPU 陷入内核,走"补充一"的按需加载流程,然后重试;
- 权限检查:页表项带着权限位。
.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,但有两处特色:
- 进程由 zygote fork 而来:zygote 启动时预加载了框架类(含
Parcel)和常用资源;fork 出的 App 进程共享这些内存页(写时复制 COW)——这就是每个 App"天生"就有android.os.Parcel可用、且启动快的内存层原因; - 堆的构成不同:ART 堆分为 Zygote Space / Allocation Space / Large Object Space(LOS,大对象如 Bitmap);Java 堆上限由设备厂商按内存规格设定(
largeHeap清单属性可申请更大); - 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 / OutputStream | Reader / 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 属性 ── 真正的字节码指令 │
└─────────────────────────────┘
字节码的三大价值:
- 跨平台:一份
.class跑遍所有有 JVM 的平台; - JIT 优化:先解释执行(启动快),热点代码 JIT 编译成优化机器码(运行快);
- 可二次加工: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):
- 连续内存缓冲区:
Parcel.obtain()从池中取一个 Parcel 对象,内部持有一块可扩容的连续内存;所有writeXxx就是把数据按约定格式平铺进这块内存; - 格式约定:
- 基本类型按固定长度直接写入(
writeInt4 字节); String写入长度 + UTF-16 编码字节;- 复杂对象递归调用其
writeToParcel(); - 内部有 4 字节对齐规则;
- 所有结构按写入位置约定,无字段名、无类型标签、无 schema;
- 基本类型按固定长度直接写入(
- Binder 传输:进程 A 把 Parcel 缓冲区交给 Binder 驱动,驱动把数据拷贝到进程 B 映射的内存中(一次拷贝),进程 B 从 Parcel 中按相同顺序
readXxx读出; - 池化回收:用完调用
recycle()归还对象池,避免频繁分配内存;Parcel 不是线程安全的,不要多线程共享。
性能高的原因:
- 无反射:字段读写顺序由开发者手写(或
@Parcelize生成); - 无元数据:不写类名、字段名、schema;
- 直接内存拷贝:经 Binder 一次拷贝直达对端,不经过中间字节流。
3.4 为什么 Parcel 不能持久化和跨网络传输
Parcel 确实是序列化,但它牺牲了通用序列化必需的三大支柱:
不能持久化的原因
- 格式没有稳定性承诺:读写格式是 AOSP 实现细节,可能随 Android 版本变化;官方文档明确说明 Parcel 不是通用序列化机制,绝不能用于持久化存储;
- 没有版本兼容机制:协议是"按位置约定",类加字段后旧数据全部错位,且静默地坏(不报错,读到垃圾数据);
- 不校验、无自描述:连"这是什么类"的信息都没有,无 checksum、无 schema 校验,落盘数据损坏时无任何防护。
不能跨网络传输的原因
- 破坏"两端环境一致"假设:依赖同 Android 版本、同架构、Binder 内核驱动参与;
writeBinder/writeFileDescriptor写入的是只在本地内核有意义的句柄; - 安全攻击面:解析端按"数据来自可信对端进程"设计,放到网络上等于把解析不可信数据的接口暴露给全网(长度不匹配、恶意构造、越界读);
- 平台差异:字节序、对齐在异构设备上直接导致数值错误。
3.5 反例印证:为什么 MMKV 能用 Parcel?
MMKV 并没有推翻规则,而是改写了风险模型:
| 层 | 用什么 | 说明 |
|---|---|---|
| 核心 KV 编码 | Protobuf | 基础类型(int/string/bool…)底层是 MMKV 自己 C++ 实现的 Protobuf 变体 |
| 对象存储 | Parcel | encodeParcelable() 调用 writeToParcel() 得到 byte[] 再存储;读取用传入的 CREATOR 反解 |
它"敢"这么做的条件:
- 写入方和读取方是同一个类(
writeToParcel与CREATOR在同一 APK 里一起编译升级)——相当于把"跨时间的持久化"退化成"本 App 内部、跨时间点的 IPC"; - 缓存语义兜底:解析失败返回 null,等价于"缓存未命中"而非"核心数据损坏";
- 文件层补充防护: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):
- 写入流头(magic number
AC ED+ 版本号); - 通过反射获取对象的类信息,写入类元数据:类全名、
serialVersionUID、字段描述列表(字段名 + 类型签名)——注意:不含方法字节码; - 递归遍历对象图:字段若是对象引用,继续序列化引用的对象;通过
ObjectStreamClass的引用表处理循环引用(同一对象只写一次,后续写引用编号); - 逐字段写出值(基本类型直接写,对象类型递归);
- 若类自定义了
writeObject,优先执行(defaultWriteObject负责默认部分); transient和static字段不写入。
反序列化时(ObjectInputStream.readObject):
- 读流头、读类元数据;
- 用类名从当前 classpath 加载类(
Class.forName)——数据传过去了,但代码必须事先部署在两端,找不到就抛ClassNotFoundException; - 校验加载到的类的
serialVersionUID与流中是否一致,不一致抛InvalidClassException; - 反射创建实例(不走构造函数!);
- 按字段描述从流中读值,反射塞进对应字段;
- 若类自定义了
readObject,执行它。
流的结构示意:
[流头 AC ED 00 05] [类元数据: 类名+serialVersionUID+字段描述] [字段值1] [字段值2] ...
4.4 关键细节
serialVersionUID:类的"身份证",用于版本校验。不显式声明时 JVM 会根据类结构自动生成——但类有任何改动(哪怕加个方法)都会变化,导致旧数据无法读取。最佳实践:显式声明private static final long serialVersionUID = 1L;。- 版本兼容规则(声明固定 serialVersionUID 后):
- 新增字段:兼容,旧数据读出后新字段为默认值;
- 删除字段:兼容,流中多余数据被忽略;
- 改字段类型:不兼容;
- 但规则脆弱,仅建议用于简单演进。
transient:修饰不参与序列化的字段(密码、缓存、句柄);反序列化后该字段是默认值(null/0),可在readObject中恢复。- 不走构造函数:反序列化直接分配内存 + 反射塞值,构造函数中的初始化逻辑不会执行——这是隐藏 bug 的高发点(如字段依赖构造时初始化的非序列化成员)。
- 静态字段不序列化:static 属于类不属于实例。
- 敏感字段必须 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 / Parcel | Serializable |
|---|---|---|
| 归属 | 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 编码后存
附:本文涉及的核心口诀
- 序列化传的是"这个对象此刻的样子","它会做什么"由两端共同的类定义决定。
- 内存中的对象不能直接传输存储,因为:引用是进程私有的、布局是运行时私有的、环境是活的、边界是隔离的。
- 字节流是载体,字节码是内容;字节流天生是二进制流;真正的对立面是文本流。
- Parcel = 进程间的 memcpy 加速版:用通用性换速度,而通用性正是持久化和网络传输不可或缺的部分。
- MMKV 能用 Parcel,是因为它把使用场景裁剪到了 Parcel 通用性覆盖的地方:同 App、同设备、缓存语义 + CRC 兜底。
- Serializable 通用但慢且危险:反射是慢的根源,"反序列化即分配 + 不走构造 + 可触发任意代码"是危险的根源。