清空一批数组,调用 System.gc(),再看进程内存:为什么几个数字没有一起下降?继续创建对象时,有时分配很快,有时线程却会停下来。应用退到后台后,还可能没有抛 Java OutOfMemoryError 就被系统结束。
理解这些现象,需要区分三个尺度:ART 管对象,Kernel 管地址空间和页,Android 按系统压力管理进程。 本章从同一个有界示例出发,先加载类和执行方法,再保留与丢弃数组、等待和通知线程,最后创建并关闭 HardwareBuffer。每一步都问清楚:谁持有什么,怎样交到下一层,何时返回或清理。
把对象位置与空间的关系想成工作台上的分格盘:拿走积木后,格子可以继续用,盘子和工作台仍可能留着。这个比喻只解释“对象位置可复用”与“空间是否归还”的差别;格子不代表固定大小的物理页,真正的分配、回收和记账要回到源码。
文章目录
- 9.1 整体架构 ART 管对象 Kernel 管页
- 9.2 准备源码 设备与观察工具
- 9.3 用一个示例区分六种内存与线程现象
- 9.4 类从哪里来 加载与初始化怎样区分
- 9.5 方法怎样执行 解释 JIT AOT 与 JNI
- 9.6 一次对象分配怎样连接到虚拟内存和缺页
- 9.7 GC 怎样识别存活对象并让分配继续
- 9.8 Java 线程怎样创建 等待 唤醒与退出
- 9.9 内存压力怎样连接 Framework lmkd mmd 与 Kernel
- 9.10 设备共享内存为什么不能只看 Java 堆
- 9.11 按问题组合日志 maps meminfo 与 Trace
- 9.12 回顾 自测 源码速查与验证边界
9.1 整体架构 ART 管对象 Kernel 管页
先区分应用代码 运行时与操作系统
Java 源文件先被编译为字节码,再由 Android 构建工具转换为 DEX。设备上的 ART 负责装载相关类型、执行方法、管理 Java 对象和线程。ART 本身有大量 C++ 实现,与应用一起运行在用户空间;它没有因为“虚拟机”这个名字就变成另一个独立进程或 Kernel 模块。
一个普通应用进程内既有 Java 堆,也有 ART 元数据、JIT 代码缓存、线程栈、Native 分配、映射的 DEX/共享库等区域。Kernel 看到的是进程地址空间、页表、物理页、任务和调度状态;它不认识某一页里第几个字节是一个 ArrayList 元素。官方 ART 概览
下图是职责和接口关系图。箭头表示调用、使用或策略输入,标注了具体关系;它不是一次 new 必经的串行流程。
先沿应用内部读,再看右侧的系统策略和设备分支。GC 回收 Java 对象、Kernel 回收页、lmkd 结束进程,是三个不同的动作。
常规对象分配、GC 和线程等待没有专属 HAL 或物理 Driver;设备缓冲区是独立分支,不能把它插入每次 Java 分配。
这些概念怎样配合
| 概念 | 解决的问题 | 在示例中怎样理解 |
|---|---|---|
| DEX | 保存 Android 可执行字节码、类型与方法信息 | APK 内的 classes.dex 包含 LazyPayload |
| ClassLoader | 按一定委派与查找规则获得类型 | getClassLoader 返回应用加载器,按名字寻找类 |
| ART Heap | 按运行时对象布局与分配器管理 Java 堆 | byte[]、持有这些引用的外层数组,以及 WeakReference 包装,都是 Java 对象 |
| GC Root | GC 可达性分析的起点 | 活动线程中的引用、静态字段、有效 JNI 引用等可使对象继续存活 |
| VMA 与页表 | 描述一段虚拟地址的属性,以及地址到页的映射 | maps 能看到映射区间;区间存在不等于所有页都驻留 |
| RSS / PSS | 观察驻留页及其共享分摊 | Java 堆之外的映射、栈、Native 页也可能计入 |
| PSI | 衡量任务因资源不足而停滞的时间 | memory some/full 是压力时间信号,不是剩余字节数 |
| DMA-BUF / native handle | 在设备与进程间共享某类缓冲区 | 图形缓冲区可以由句柄和 fd 表达,主体不在 Java 对象字段里 |
“线程中的引用是 Root”不意味着每个源代码局部变量都一直保活到方法结尾。编译后的活跃性、寄存器/栈映射和运行时扫描规则决定某个时刻哪些引用有效。后面的示例用明确的字段持有数组,不依赖局部变量是否仍被优化器视为活跃。
不要把三个内存数相减后称作泄漏
Runtime.totalMemory() - freeMemory() 近似描述当前 Java 堆已使用量,maxMemory() 是运行时允许的堆上限之一;它们都不是“手机 RAM 总量”。Debug.getNativeHeapAllocatedSize() 来自 Native 分配器统计,也不是进程所有非 Java 内存之和。
RSS 统计当前驻留的映射页;PSS 对共享页按共享情况分摊,因此同一进程的 PSS 可能因为其他进程的映射情况变化而改变。Swap、SwapPss、共享图形内存等还要按工具字段另读。对象失去引用、GC 回收对象槽位、ART 归还页、系统统计下降,并不保证同时发生。
9.2 准备源码 设备与观察工具
沿用设备类型 重新记录本轮身份
实验使用 Linux x86_64 AOSP 工作站和 emu64x / x86_64 SDK Emulator,serial、PID、GC 方案与服务状态以本轮设备为准。源码采用9.12列出的固定提交;源码树、构建产物与正在运行的镜像需分别核对身份。启动实验设备后,在 Host 终端 A 执行:
ch9_top="/absolute/path/to/aosp" # 替换为自己的 AOSP 根目录
ch9_run=$(mktemp -d "$HOME/aosp-chapter9.XXXXXX")
ch9_chapter="$ch9_run/materials"
mkdir -p "$ch9_chapter/示例"
ch9_adb="$ch9_top/out/host/linux-x86/bin/adb"
test -x "$ch9_adb" || exit 1
"$ch9_adb" devices -l
read -r -p '输入本轮设备 serial:' ch9_serial
test -n "$ch9_serial" || exit 1
"$ch9_adb" -s "$ch9_serial" shell getprop ro.build.fingerprint
"$ch9_adb" -s "$ch9_serial" shell uname -a
"$ch9_adb" -s "$ch9_serial" shell getprop sys.boot_completed
成功判据是选中的设备可连接、boot_completed 为 1,输出可保存到本轮目录。设备列表为空时先检查模拟器是否已启动、ADB路径与连接状态,再重新选择;设备准备可回看本系列第一章。下面的主实验不要求 adb root;读 /proc、Trace 或 HAL 细节受权限限制时,保留错误与停止位置,不把读取失败解释为“该机制不存在”。
带着问题定位源码
| 问题 | 主要入口 |
|---|---|
| 一个类按什么顺序查找 | libcore 的 ClassLoader、BaseDexClassLoader、DexPathList、DexFile |
| 类怎样成为 ART 类型 | ART 的 ClassLinker、java_lang_Class.cc、dalvik_system_DexFile.cc |
| 方法进入哪个执行入口 | ArtMethod、interpreter、jit、compiler、dex2oat |
| 对象从哪里分配 | gc/heap-inl.h、mirror/array-alloc-inl.h、Thread::AllocTlab |
| 为什么等待 GC | gc/heap.cc、gc/collector、gc/task_processor.cc |
| Java 线程与 Linux 线程怎样关联 | Thread.java、java_lang_Thread.cc、thread.cc、Bionic pthread_create |
| 为什么系统结束应用 | Framework 的 psc/OomAdjusterImpl、ProcessList、lmkd、Kernel mm |
| 设备缓冲区的主体在哪里 | HardwareBuffer JNI、GraphicBuffer、实际 Allocator/Mapper、设备后端 |
cd "$ch9_top"
rg -n 'AllocObjectWithAllocator|AllocateInternalWithGc' art/runtime/gc/heap-inl.h
rg -n 'FindClass|DefineClass|InitializeClass' art/runtime/class_linker.cc
rg -n 'MaybeEnqueueCompilation' art/runtime/jit/jit.cc
rg -n 'PSI|init_mp_psi|kill_one_process' system/memory/lmkd/lmkd.cpp
本版本的 OomAdjuster 主要实现位于 services/core/java/com/android/server/am/psc/。按类名和函数定位,不要照旧文章的目录猜测实现。Kernel 源码不在当前 AOSP kernel/ 顶层完整展开;本章使用固定 ACK 公开文件,版本见 9.12,不能把 kernel/configs 当成 Kernel mm 实现。
9.3 用一个示例区分六种内存与线程现象
准备完整输入 再构建 APK
下述构建、安装与运行步骤是跟做方法,本章未实际执行;表中的日志顺序和现象,是根据示例代码与源码推导的预期。
Chapter9MemoryDemo是minSdk 28的普通可调试应用,没有自编译Native库和特殊权限。先按同篇附录A的文件路径,把完整输入保存到 $ch9_chapter/示例/,再执行本节构建。Activity 的工作由单线程 Executor 串行运行;生命周期回调仍在主线程。wait/notify 实验另建两个命名线程,HardwareBuffer 在本次任务的 try-with-resources 中关闭。
| 文件 | 用途 |
|---|---|
| AndroidManifest.xml | 声明普通 Activity 与 debuggable |
| Android.bp.example | 可选 Soong 模块模板,复制入实验源码树后改名 |
| src/com/example/memorydemo/MainActivity.java | 六项实验、内存快照、线程清理 |
| src/com/example/memorydemo/LazyPayload.java | 用静态初始化日志区分类加载和初始化 |
在同一Host终端A使用附录A的独立构建脚本“构建示例APK.py”。它复用工程已有 javac、D8、aapt2、signapk、SDK 和测试密钥,只生成普通 APK;这些 Host 产物须事先存在。脚本会拒绝非空输出目录,缺工具时列出具体路径。
python3 "$ch9_chapter/示例/构建示例APK.py" \
--aosp-top "$ch9_top" \
--module "$ch9_chapter/示例/Chapter9MemoryDemo" \
--name Chapter9MemoryDemo \
--out "$ch9_run/apk"
test -f "$ch9_run/apk/Chapter9MemoryDemo.apk" || exit 1
"$ch9_adb" -s "$ch9_serial" install -r "$ch9_run/apk/Chapter9MemoryDemo.apk"
"$ch9_adb" -s "$ch9_serial" shell am start -W \
-n com.example.memorydemo/.MainActivity
构建脚本退出为 0、APK 可定位、安装成功、Activity 启动成功,是四个不同判据。 am start -W 的启动时间不是某个方法的 JIT 耗时。若构建失败,先对照缺失工具、SDK、Java 编译和签名步骤;若安装失败,再查 ABI/SDK、包签名或设备空间,不把 Host 编译问题归到 GC。
需要练习Soong时,把附录A的四个应用文件另存到专用实验目录 packages/apps/Chapter9MemoryDemo,加载第一章的构建环境后执行 m Chapter9MemoryDemo。构建模板保留.example后缀;复制到专用模块后再改为Android.bp。已有同名目录先检查内容,不直接覆盖。独立 APK 构建和 Soong 构建分别记录,不能互相声称通过。
先看操作与预期的对应
第一次按按钮前,先按9.11“先保留每一步前后的同轮快照”保存before,每次只运行一项,结束后再保存对应after;wait是否正常仍按三种结果判据判断。另开 Host终端B 持续看日志。两个终端不共享变量,在终端 B 重新设置 adb 路径与设备号:
ch9_adb="/absolute/path/to/aosp/out/host/linux-x86/bin/adb" # 替换为同一工程路径
"$ch9_adb" devices -l
read -r -p '输入同一实验设备 serial:' ch9_serial
"$ch9_adb" -s "$ch9_serial" logcat -v threadtime \
Chapter9Memory:I art:I lowmemorykiller:I '*:S'
ART 的 GC 日志不一定使用 art 标签;需要完整上下文时在日志中按应用 PID 检索,同时保留未过滤输出。发生 adbd 重启、断连或设备重启后,应重新启动日志观察,不把旧监听窗口当作已经恢复。
| 操作 | 依据代码的预期 | 不能直接推出什么 |
|---|---|---|
| 类加载与初始化 | initialize=false 的返回先于首次 clinit 日志;之后 add=15 | 每次点击都重新加载、重新初始化或一定走解释器 |
| 保留 8 MiB 并写入 | 字段持有 32 个数组;运行时余量不足时跳过 | RSS 必须恰好增加 8 MiB,或所有数组都走 TLAB |
| 产生短命对象 | 累计创建 32 MiB 负载,只保留末尾 64 个数组 | 总分配量等于当前活跃量,或一定立即触发某种 GC |
| 清除引用并请求 GC | 本应用的 retained/sink 引用被清空,可能观察到弱引用清除 | GC 必定完成、所有页归还、PSS 必须下降 |
| wait 与 notifyAll | 分别按 9.11 的正常完成、join 超时取消、退出取消判据判断;正常路径依次观察等待、业务通知与重新取得锁 | 单看 released=true 就证明业务通知成功,或 notifyAll 与恢复执行没有间隔 |
| HardwareBuffer 创建与关闭 | 成功时取得缓冲区包装,并在任务结束前关闭 | 已经向 GPU 提交一帧、主体内存属于 Java 堆或必为 DMA-BUF |
保留实验写满每个字节,不假设 4 KiB 页大小。写入可能触发新页、COW、已经驻留的页或大页相关路径;只有进一步的缺页证据才能判断具体情况。反复点击“保留”会替换上一批字段引用,不是一直累计八兆。
明确示例中的引用和退出责任
保留数组由 retained 字段持有;短命实验只把小环形数组交给 sink。watched 是观察第一块数组的弱引用,不为它提供强保活。示例不把 WeakReference 清除当成物理页释放的证明。
onDestroy 标记 closing,记录 closing: cancel wait pair and pending work,再释放等待条件、打断两个实验线程并停止工作队列;同时清空三个引用字段。在途任务的 finally 再检查 closing,处理“主线程已清空,工作线程稍后才写回字段”的窗口。它没有在主线程阻塞等待线程退出,也不声称 shutdownNow 一调用线程就已退出。
完整代码见同篇附录A,下文按当前问题摘录关键节点。
9.4 类从哪里来 加载与初始化怎样区分
同名不等于同一个类型
Java 运行时区分类型时,还需要考虑定义它的 ClassLoader。应用加载器、BootClassLoader 与按需建立的加载器有各自来源;两个加载器分别定义同名类,不能仅凭类名就认为对象可以相互强制转换。
“加载”获得类型及其相关元数据;“链接”涉及验证、解析与布局等工作;“初始化”执行需要的静态初始化逻辑。实际实现允许惰性解析和缓存,不应把这三个词画成每次方法调用都完整重做的过程。
示例先调用:
Class<?> loaded = Class.forName(name, false, loader);
Class.forName(name, true, loader);
第二行才明确请求初始化。 LazyPayload 的静态块打印 <clinit>;同一加载器的同一类型通常只完成一次成功初始化。若之前已初始化,第二次点击没有新日志很正常。显式的不存在类名则用于观察 ClassNotFoundException。
从加载器走到 DEX 与 ART
下图以 Java 加载器的委派分支说明查找自己的 DEX 时的控制路径;已加载、父加载器、共享库命中可以提前返回。
图中合并展示了不同入口的概念路线:Class.forName 有 ART FindClass 入口,ClassLoader.loadClass 有 Java 委派入口,两者不能误写成“forName 必定先进入下面这段 Java loadClass”。缓存命中只省去重新加载;如果调用者仍请求初始化,就还要检查初始化状态。普通 loadClass 本身不等于请求执行 clinit。
先对齐示例 Class.forName 的真实入口
示例的 Class.forName 经 Class.classForName 进入 ART 后,先请求 ClassLinker 查找:
来源:art/runtime/native/java_lang_Class.cc,符号 Class_classForName 内的连续原文摘录。
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Handle<mirror::Class> c = hs.NewHandle(
class_linker->FindClass(soa.Self(), descriptor.c_str(), descriptor.length(), class_loader));
对能识别的 BaseDexClassLoader 层次,ART 可以直接在 Native 侧按加载器结构查找:
来源:art/runtime/class_linker.cc,符号 ClassLinker::FindClass 内的连续原文摘录。
bool known_hierarchy = FindClassInBaseDexClassLoader(
self, descriptor, descriptor_length, hash, class_loader, &result_ptr);
if (result_ptr != nullptr) {
其中,负责查找自身 DEX class path 的函数定位到 ClassDef 后,会进入同一个 DefineClass:
来源:art/runtime/class_linker.cc,符号 ClassLinker::FindClassInBaseDexClassLoaderClassPath 内的连续原文摘录。
if (class_def != nullptr) {
*result =
DefineClass(self, descriptor, descriptor_length, hash, class_loader, *dex_file, *class_def);
这条 Native 快路径与下面的 Java 查找分支是替代关系,成功时不会逐个回调下面所有 Java 函数。 识别不了的层次、未命中或自定义加载器可能回到 Java loadClass;缓存命中则可以更早返回。示例日志用于观察初始化与返回结果,不能当作每个内部函数均执行过的 Trace。
再用 Java 分支理解缓存与委派
执行者是请求加载的应用线程;这是普通 Java 调用,不因换了类就换线程。ClassLoader.loadClass(name, resolve) 的委派节点:
来源:libcore/ojluni/src/main/java/java/lang/ClassLoader.java,符号 loadClass 内的连续原文摘录。
Class<?> c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
父加载器未能返回类型后,当前加载器才有机会查找:
来源:libcore/ojluni/src/main/java/java/lang/ClassLoader.java,符号 loadClass 内的连续原文摘录。
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
c = findClass(name);
findClass 是当前加载器的具体查找入口,findLoadedClass 是已加载结果查询。 返回对象、继续查找、抛异常分别对应不同结果。BaseDexClassLoader 还会按配置处理共享库加载器,不是任何情况下都只有简单父子两层。
从路径集合取出真正的 DEX 元素
来源:libcore/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java,符号 findClass 内的连续原文摘录。
List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
Class c = pathList.findClass(name, suppressedExceptions);
if (c != null) {
return c;
}
DexPathList 接着逐个查找:
来源:libcore/dalvik/src/main/java/dalvik/system/DexPathList.java,符号 findClass 内的连续原文摘录。
for (Element element : dexElements) {
Class<?> clazz = element.findClass(name, definingContext, suppressed);
if (clazz != null) {
return clazz;
}
}
路径对象和 DEX cookie 先前随加载器建立并保存,不是每查一个类就重读整个 APK。 在构建这个加载器时,BaseDexClassLoader 保存路径对象:
来源:libcore/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java,符号 BaseDexClassLoader 内的连续原文摘录。
this.pathList = new DexPathList(this, dexPath, librarySearchPath, null, isTrusted);
DexPathList 构建 DEX 元素,打开相应 DexFile;这个 Java DexFile 的构造函数保存 cookie:
来源:libcore/dalvik/src/main/java/dalvik/system/DexFile.java,符号 DexFile 内的连续原文摘录。
mCookie = openDexFile(fileName, null, 0, loader, elements);
mInternalCookie = mCookie;
mFileName = fileName;
openDexFile 经 openDexFileNative 进入 ART,OatFileManager 获得适用的 OAT/DEX 结果后,用它构造 cookie:
来源:art/runtime/native/dalvik_system_DexFile.cc,符号 DexFile_openDexFileNative 内的连续原文摘录。
std::vector<std::unique_ptr<const DexFile>> dex_files =
Runtime::Current()->GetOatFileManager().OpenDexFilesFromOat(sourceName.c_str(),
class_loader,
dex_elements,
/*out*/ &oat_file,
/*out*/ &error_msgs);
return CreateCookieFromOatFileManagerResult(env, dex_files, oat_file, error_msgs);
在成功构造的路径中,ConvertDexFilesToJavaArray 创建 long 数组,将 Native 对象关联编码到对应索引:
来源:art/runtime/native/dalvik_system_DexFile.cc,符号 ConvertDexFilesToJavaArray 内的连续原文摘录。
long_data[kOatFileIndex] = reinterpret_cast64<jlong>(oat_file);
for (size_t i = 0; i < vec.size(); ++i) {
long_data[kDexFileIndexStart + i] = reinterpret_cast64<jlong>(vec[i].get());
}
这里的地址属于当前进程的 Native 对象;相关 DEX/OAT 生命周期由 ART、加载器关联和关闭规则共同管理,Java cookie 是其关联载体,不是另一份完整 DEX 内容。缓存和既有映射可以复用,不能从这些指针推导“每个类单独 mmap 一次”。
准备好这些关联后,DexPathList.Element.findClass 对有效 dexFile 调用 loadClassBinaryName,后者再进入 DexFile 的 defineClass 包装:
来源:libcore/dalvik/src/main/java/dalvik/system/DexFile.java,符号 defineClass 内的连续原文摘录。
Class result = null;
try {
result = defineClassNative(name, loader, cookie, dexFile);
} catch (NoClassDefFoundError e) {
cookie 是 Java 对 Native DEX 相关对象的关联载体;它不是“一个普通 Java 引用可以直接在 C++ 中解引用”的证明。DexFile_defineClassNative 先通过 ConvertJavaArrayToDexFiles 取回已打开的 DEX 集合,再查到对应 ClassDef,并交给 ClassLinker:
来源:art/runtime/native/dalvik_system_DexFile.cc,符号 DexFile_defineClassNative 内的连续原文摘录。
ObjPtr<mirror::Class> result = class_linker->DefineClass(soa.Self(),
descriptor.c_str(),
descriptor.length(),
hash,
class_loader,
*dex_file,
*dex_class_def);
交出的结果是 ART 的类型对象。 ClassLinker 还负责状态、类表、依赖、字段和方法等关联;同名类与加载器的绑定不能省略。成功后 JNI 以本地引用返回 Java Class;失败可能保留异常,也可能让上层继续查找其他 DEX 元素,不能把 nullptr 一律解释为系统崩溃。
初始化如何落实到第一段静态代码
Class.classForName 在找到 Class 后检查 initialize 参数:
来源:art/runtime/native/java_lang_Class.cc,符号 Class_classForName 内的连续原文摘录。
if (initialize) {
class_linker->EnsureInitialized(soa.Self(), c, true, true);
}
ClassLinker 的初始化流程先处理状态、并发初始化等待和所需父类型等,再找到本类型的初始化方法:
来源:art/runtime/class_linker.cc,符号 ClassLinker::InitializeClass 内的连续原文摘录。
ArtMethod* clinit = klass->FindClassInitializer(image_pointer_size_);
if (clinit != nullptr) {
CHECK(can_init_statics);
JValue result;
clinit->Invoke(self, nullptr, 0, &result, "V");
}
<clinit> 是初始化方法,不是每个实例的构造方法。 初始化失败需要传播或记录错误状态;后续再使用该类,异常形态可能不同于第一次失败。应用加载器的生命周期通常与应用进程相同,清空某个实例引用不会卸载应用所有类;类卸载还受 ClassLoader、Class 和其他可达对象约束。
9.5 方法怎样执行 解释 JIT AOT 与 JNI
同一段 Java 可以有不同执行入口
| 方式 | 核心含义 | 观察时的边界 |
|---|---|---|
| 解释执行 | 运行时按 DEX 指令执行;存在不同解释器实现 | 不能只凭“第一次调用较慢”判断在解释 |
| JIT | 运行中对选中的方法或路径生成机器码 | 需要热度、策略、任务执行与代码安装等条件 |
| AOT | 在运行前或后台优化阶段生成适用的编译产物 | 安装成功不等于所有方法都已完全编译 |
| JNI | 通过规定接口调用 Native 实现或从 Native 调回托管代码 | 它是边界与契约,不是另一个进程或自动线程切换 |
DEX 仍保存可执行语义。JIT、AOT 与 profile 配合时,可只优化部分方法;版本、ISA、类加载上下文、调试状态和运行时配置都会影响入口。不要用“ART 把所有 Java 在安装时一次性变成机器码”概括当前系统。官方 JIT 说明
下面是执行方式的概念图,编译任务与方法调用分开表示;已经内联或直接连接的编译调用可以省去部分入口检查,不要求每次调用都走一次统一的 C++ 分派器。
实线是执行路径,虚线是代码产生与安装关系,不表示应用每次调用都同步等待 JIT 编译。
用一个可定位的入口理解分派
示例使用反射调用 add,便于观察参数、结果与异常。反射及某些运行时调用可以落到 ArtMethod::Invoke。正常编译代码中的所有方法调用并不都要经过这个 C++ 函数;直接调用、内联、解释器与桥接路径另有入口。
在这个入口中,运行时尚未启动或需要强制解释时有明确分支:
来源:art/runtime/art_method.cc,符号 ArtMethod::Invoke 内的连续原文摘录。
if (UNLIKELY(!runtime->IsStarted() ||
(self->IsForceInterpreter() && !IsNative() && !IsProxyMethod() && IsInvokable()))) {
if (IsStatic()) {
art::interpreter::EnterInterpreterFromInvoke(
self, this, nullptr, args, result, /*stay_in_interpreter=*/ true);
具备相应入口时,它也可以进入 quick invoke 桥:
来源:art/runtime/art_method.cc,符号 ArtMethod::Invoke 内的连续原文摘录。
if (!IsStatic()) {
(*art_quick_invoke_stub)(this, args, args_size, self, result, shorty);
} else {
(*art_quick_invoke_static_stub)(this, args, args_size, self, result, shorty);
}
ArtMethod 保存和使用方法执行入口;入口地址还可能指向桥、解释器或需要检查的桩。 因而“入口非空”也不能单独证明 add 已由 JIT 编译。调用结束后 JValue 承接结果;异常则保留在当前线程的运行时状态,反射层可能包装为 InvocationTargetException。
JIT 是另一条有策略条件的工作路径
Jit::MaybeEnqueueCompilation 在考虑任务之前先检查配置:
来源:art/runtime/jit/jit.cc,符号 Jit::MaybeEnqueueCompilation 内的连续原文摘录。
if (!UseJitCompilation()) {
return;
}
if (IgnoreSamplesForMethod(method)) {
return;
}
随后还检查是否已有代码、预编译入口、方法状态和编译类型等。解释器采样、热度与编译任务通过运行时的规则衔接,编译线程产生可用代码后再更新对应入口。热循环耗时变短只能提出假设;缓存、CPU 频率、调度、GC 和编译都可能影响时间。
阅读入口是 runtime/jit/jit.cc 的 MaybeEnqueueCompilation、AddCompileTask、CompileMethod,以及 jit_code_cache;AOT 阅读 dex2oat/、compiler/,设备侧策略还需要检查 ART Service 和产品配置。可先看 adb shell cmd package help 支持的观察入口,不要为了测一次调用把全系统编译策略改掉。
Native 库加载和 JNI 引用同样要追来源
Java 的 System.loadLibrary/Runtime.loadLibrary0 先定位库名;Runtime.nativeLoad 经 libcore Runtime.c 的 JVM_NativeLoad 进入 ART 的 JavaVMExt::LoadNativeLibrary。这里把类加载器和库路径交给 NativeLoader:
来源:art/runtime/jni/java_vm_ext.cc,符号 JavaVMExt::LoadNativeLibrary 内的连续原文摘录。
void* handle = android::OpenNativeLibrary(
env,
runtime_->GetTargetSdkVersion(),
path_str,
class_loader,
(caller_location.empty() ? nullptr : caller_location.c_str()),
library_path.get(),
&needs_native_bridge,
&nativeloader_error_msg);
NativeLoader 处理命名空间,Bionic linker 装载 ELF 段并处理依赖与重定位;映射需要时再落到 mmap 与文件页。已装载或命名空间/路径不允许时,结果各不相同。ART 取得库句柄,检查 JNI_OnLoad 符号,存在时执行:
来源:art/runtime/jni/java_vm_ext.cc,符号 JavaVMExt::LoadNativeLibrary 内的连续原文摘录。
using JNI_OnLoadFn = int(*)(JavaVM*, void*);
JNI_OnLoadFn jni_on_load = reinterpret_cast<JNI_OnLoadFn>(sym);
int version = (*jni_on_load)(this, nullptr);
库句柄、Native 函数地址、jobject/jclass 引用是三种不同东西。 RegisterNatives 建立方法与函数的关联;JNIEnv 属于线程,Native 自建线程访问 Java 前需按契约附加到 VM,并在适用时分离。Local Reference 的作用域、Global Reference 的显式删除、数组元素获取/释放都影响对象保活与资源责任。官方 JNI 指南
本章示例直接使用系统已有 JNI,不附带自定义 .so。加载失败、ABI 不匹配、JNI_OnLoad 返回错误或 JNI 异常都沿各自接口返回;不能把某次找不到符号归到 Java 堆空间不足。
9.6 一次对象分配怎样连接到虚拟内存和缺页
new 的第一责任人是 ART 分配器
new byte[4096] 需要确定数组类型与长度、计算对象大小、取得内存、写入对象头/数组长度等。不同执行路径可以内联部分工作,也可以进入 runtime entrypoint。示例数组没有负长度;若长度非法,首先可能是 NegativeArraySizeException,而不是“内核没有内存”。
以已解析数组的 runtime 路径为阅读入口,AllocArrayFromCodeResolved 把数组类、长度、元素大小和分配器交给 mirror::Array::Alloc。后者计算好大小后,调用 Heap:
来源:art/runtime/mirror/array-alloc-inl.h,符号 Array::Alloc 内的连续原文摘录。
gc::Heap* heap = Runtime::Current()->GetHeap();
ObjPtr<Array> result;
if (!kFillUsable) {
SetLengthVisitor visitor(component_count);
result = ObjPtr<Array>::DownCast(
heap->AllocObjectWithAllocator<kIsInstrumented>(
self, array_class, size, allocator_type, visitor));
Java 数组对象的分配位置是 ART 管理的堆空间,返回值最终成为当前线程可使用的托管引用。 大对象、插桩、不同 collector/allocator 和编译快路径会产生分支,不能把一个 runtime 模板函数当成每次 new 都逐语句执行的证据。
TLAB 为什么能让小对象分配很快
TLAB 是 Thread Local Allocation Buffer,线程本地分配缓冲区。运行时先为线程准备一段可分配空间,小对象可从里面顺次取出位置,减少每次分配时对全局分配器的争用。使用 TLAB 的 allocator 且空间足够时:
来源:art/runtime/gc/heap-inl.h,符号 Heap::AllocObjectWithAllocator 内的连续原文摘录。
if (IsTLABAllocator(allocator) && byte_count <= self->TlabSize()) {
obj = self->AllocTlab(byte_count);
DCHECK(obj != nullptr) << "AllocTlab can't fail";
obj->SetClass(klass);
if (kUseBakerReadBarrier) {
Thread::AllocTlab 中的核心动作很短:
来源:art/runtime/thread-inl.h,符号 Thread::AllocTlab 内的连续原文摘录。
DCHECK_GE(TlabSize(), bytes);
++tlsPtr_.thread_local_objects;
mirror::Object* ret = reinterpret_cast<mirror::Object*>(tlsPtr_.thread_local_pos);
tlsPtr_.thread_local_pos += bytes;
return ret;
它推进的是当前线程的分配指针,不是每个对象都向 Kernel 申请新页。 TLAB 用完、对象过大、allocator 不同或需要特殊处理时,再走其他分配路径。保留实验中的 256 KiB primitive array 可能按大对象策略处理,因此不能把其结果当成“小对象 TLAB 性能实验”。
分配不成功怎样进入等待 重试和 OOME
初次尝试不成功时,Heap 进入有 GC 协调的慢路径:
来源:art/runtime/gc/heap-inl.h,符号 Heap::AllocObjectWithAllocator 内的连续原文摘录。
obj = AllocateInternalWithGc(self,
allocator,
kInstrumented,
byte_count,
&bytes_allocated,
&usable_size,
&bytes_tl_bulk_allocated,
&klass);
当前分配线程在 AllocateInternalWithGc 中可能先等待已有 GC:
来源:art/runtime/gc/heap.cc,符号 Heap::AllocateInternalWithGc 内的连续原文摘录。
collector::GcType last_gc =
PERFORM_SUSPENDING_OPERATION(WaitForGcToComplete(kGcCauseForAlloc, self));
// If we were the default allocator but the allocator changed while we were suspended,
// abort the allocation.
if ((was_default_allocator && allocator != GetCurrentAllocator()) ||
(!instrumented && EntrypointsInstrumented())) {
return nullptr;
}
接着按本版本策略尝试重新分配、适当 GC、清理 SoftReference 或压缩等步骤。分配器可能在挂起期间变化,所以函数还要重新检查 allocator 和 instrumentation,不能省略这一步,把 null 一概写成“必定 OOME”。真正耗尽当前可行重试后:
来源:art/runtime/gc/heap.cc,符号 Heap::AllocateInternalWithGc 内的连续原文摘录。
// Throw an OOM error.
{
ScopedAllowThreadSuspension ats;
ThrowOutOfMemoryError(self, alloc_size, allocator);
}
return nullptr;
}
OutOfMemoryError 是这条托管分配失败路径的结果,不能反推整机所有物理页都用尽。 Java 堆上限、碎片、地址空间、Native 分配及具体请求大小都可能影响失败;线程创建也可能因资源不足抛出同类错误,定位时要读完整异常信息。
堆空间何时连到 mmap
堆空间需要映射或扩展时才可能向 Kernel 建立相应区间。下面以 ART 的 BumpPointerSpace 创建为独立例子,不声称本轮数组一定使用这个 space:
来源:art/runtime/gc/space/bump_pointer_space.cc,符号 BumpPointerSpace::Create 内的连续原文摘录。
MemMap mem_map = MemMap::MapAnonymous(name.c_str(),
capacity,
PROT_READ | PROT_WRITE,
/*low_4gb=*/ true,
&error_msg);
if (!mem_map.IsValid()) {
MemMap::MapAnonymous 做页对齐、地址与预留区域检查,按相应分支调用 MapInternal:
来源:art/libartbase/base/mem_map.cc,符号 MemMap::MapAnonymous 内的连续原文摘录。
actual = MapInternal(addr, page_aligned_byte_count, prot, flags, fd.get(), 0, low_4gb);
Linux 平台的 MapInternal 再经 TargetMMap 落到系统接口:
来源:art/libartbase/base/mem_map_unix.cc,符号 MemMap::TargetMMap 内的连续原文摘录。
return mmap(start, len, prot, flags, fd, fd_off);
MemMap 是映射的 Native 包装与所有权管理对象;Java 对象是这片或其他堆空间中的对象,两者不是一对一分配。 RegionSpace、LargeObjectSpace 等有各自实现。映射失败先沿 errno 和运行时返回查,不要因为看到 MapAnonymous 名字就假定已经占用了同样多的私有驻留 RAM。
缺页由访问触发 并返回原指令继续
观察后面的过程:先在使用TLAB且余量足够的分支,看线程分配指针如何推进,再切换到Space需要映射的条件例子,分清建立虚拟区间、访问缺页与返回原指令。它们不是每次new都依次经过的步骤;图中只示意一个对象/页关系,不表示实际数量或大小比例。
图中缺页段是条件路径:页已有效驻留时直接访问,不发生这次异常。缺页也可能发生在分配器初始化对象头、清零数组等操作期间;图只展示分配返回后的后续访问这一时机,没有把缺页固定在 new 返回之后。Kernel 并没有回调 Java 的数组构造函数。
在固定 ACK 的 mm/memory.c 中,匿名缺页路径会考虑零页、userfaultfd、页表状态等条件。需要取得私有匿名页的分支有:
来源:kernel/common/mm/memory.c,符号 do_anonymous_page 内的连续原文摘录。
folio = alloc_anon_folio(vmf);
if (IS_ERR(folio))
return 0;
if (!folio)
goto oom;
后续设置页表、权限与记账,成功后回到原线程。读匿名区域可以利用零页;写入、COW、文件映射与 userfaultfd 处理并不是同一条分支。 页可能以 folio/大页粒度管理,不能把 Java 每个数组和某个物理页绑定成永久关系。错误可能导致重试、SIGBUS/SIGSEGV 或内存不足处理,不能保证都能被 Java try/catch 直接捕获。
9.7 GC 怎样识别存活对象并让分配继续
GC 回收的是不可达对象 而不是不再想要的变量名
先看示例retainDemo怎样创建这条引用链。以下是同篇附录A中同名方法的连续摘录:
byte[][] next = new byte[32][];
for (int i = 0; i < next.length; i++) {
if (closing || Thread.currentThread().isInterrupted()) throw new InterruptedException();
next[i] = new byte[256 * 1024];
// 每个字节均写入;不依赖设备页大小,也不宣称逐一观察到缺页。
java.util.Arrays.fill(next[i], (byte) (i + 1));
}
retained = next;
watched = new WeakReference<>(next[0]);
retained = next让字段持有外层数组,外层数组再持有byte[];watched仅弱关联其中第一块。 余量检查和中断处理仍在附录完整实现中,下面用这些引用关系说明GC过程。
观察强引用边怎样连到数组;删除retained这条边后,只在没有其他强保活、且后续收集覆盖该对象时才可能回收。动画会保留地址空间轮廓,帮助区分对象槽位复用与物理页归还,不表示实际GC时长。
以 retained 字段为例:Activity 仍被运行时/应用生命周期关联,字段指向外层数组,外层数组再指向 32 个 byte 数组,GC 因而仍可到达它们。把 retained 设为 null 只删除其中一条强引用;若另一个线程、集合或 JNI Global Reference 还指向对象,它仍可能存活。
实线持有关系与“删除引用”操作在边上分别标明;虚线表示弱关联。GC 能处理对象之间的循环,只要这组对象整体已不能从 Root 强到达。
当前源码同时保留多种 collector
collector 负责执行收集算法,allocator 负责分配;二者配合但不是同一概念。并发 collector 允许部分工作与应用线程同时执行,仍可能有暂停、同步、读/写屏障及分配等待。
本版本 Heap 的 collector 选择包含 CMC 与 CC 等实现:
来源:art/runtime/gc/heap.cc,符号 Heap::CollectGarbageInternal 内的连续原文摘录。
case kCollectorTypeCMC:
collector = mark_compact_;
if (use_generational_gc_ && gc_type == collector::kGcTypeSticky) {
collector = young_mark_compact_;
}
break;
CMC 是 Concurrent Mark Compact 相关方案,CC 是 Concurrent Copying。代码还涉及代际收集、userfaultfd 等条件;本章不凭 Android 版本号或一个目录存在就宣称设备使用哪一种。旧文中“默认一直是某算法”的说法,需用所读版本配置、启动选项和设备证据重新核对。
以 MarkCompact 的阶段组织说明“并发与暂停交替”的含义:
来源:art/runtime/gc/collector/mark_compact.cc,符号 MarkCompact::RunPhases 内的连续原文摘录。
MarkingPhase();
// From here, until we re-enable full weak-reference access, we are potentially blocking high
// priority threads.
spc.SetToNormalOrBetter();
}
MarkingPause();
MarkingPhase 之后有 MarkingPause,再进入回收/压缩等阶段。这段代码只展示当前 collector 的阶段交接;不是“一次暂停覆盖整个 GC”的证明,也不是所有 collector 的统一流程。读屏障、写屏障、卡表/记忆集等用于维持当前算法需要的关系,不能用一条泛化口诀替代实现。
把 retained 代入 Root 标记 扫描与空间回收
可达图怎样成为运行时的“已标记”?继续以本固定版本的 MarkCompact、且对象属于本次收集范围为例,执行者是该次 GC 的执行线程及参与 Root checkpoint 的应用线程;这里不据此确认设备当前选择了 CMC。
MarkingPhase 调用 MarkRoots 和 MarkReachableObjects。MarkRoots 汇聚线程 Root、非线程 Root 与并发 Root:
来源:art/runtime/gc/collector/mark_compact.cc,符号 MarkCompact::MarkRoots 内的连续原文摘录。
MarkRootsCheckpoint(thread_running_gc_, runtime);
MarkNonThreadRoots(runtime);
MarkConcurrentRoots(flags, runtime);
Root 是扫描起点,retained 是从已到达的 Activity 继续读到的一条字段引用。 MarkRootsCheckpoint 让相关线程执行 checkpoint;VisitRoots 的标记分支把 Root 指向的对象交给 MarkObjectNonNull。其 MarkObjectNonNullNoPush 按所属 space 更新标记位图,并决定是否需要入 mark stack;已处理对象不再作为首次发现重复入栈,大对象和代际范围还各有分支。
在这条标记路径里,标记位图是GC对“哪些对象位置已标记”的记录,mark stack是“还要继续检查其引用的对象清单”。前者帮助避免重复发现,后者使扫描继续;适用space与代际仍按上文条件判断。
待处理栈怎样接到字段扫描?ProcessMarkStack 取出对象,再交给 ScanObject:
来源:art/runtime/gc/collector/mark_compact.cc,符号 MarkCompact::ProcessMarkStack 内的连续原文摘录。
while (!mark_stack_->IsEmpty()) {
mirror::Object* obj = mark_stack_->PopBack();
DCHECK(obj != nullptr);
ScanObject</*kUpdateLiveWords=*/true>(obj, visitor);
}
ScanObject 取得对象的类与大小、更新相应存活信息,随后访问引用:
来源:art/runtime/gc/collector/mark_compact.cc,符号 MarkCompact::ScanObject 内的连续原文摘录。
visitor.Reset();
obj->FastVisitReferences</*kVisitNativeRoots=*/true, kVerifyNone, kWithoutReadBarrier>(visitor,
visitor);
这里的 RefFieldsVisitor 按字段偏移取出引用并继续 MarkObject,因此可从 Activity 追到 retained 外层数组,再追到其中的 byte 数组。Object::FastVisitReferences 对对象数组访问元素引用;primitive byte[] 的元素是数值,不是要继续追踪的对象引用,但对象的类型等必要元数据仍需处理。watched 强持有的 WeakReference 包装可以被正常追到,referent 则交给专门的引用处理,不能借这条弱关联给数组强保活。
标记结果怎样用于回收?ReclaimPhase 先做引用处理、系统弱引用处理等工作,再在相应位图锁范围内执行:
来源:art/runtime/gc/collector/mark_compact.cc,符号 MarkCompact::ReclaimPhase 内的连续原文摘录。
Sweep(false);
// Swap the live and mark bitmaps for each space which we modified space. This is an
// optimization that enables us to not clear live bits inside of the sweep. Only swaps unbound
// bitmaps.
SwapBitmaps();
未标记不等于“立刻释放每个地址”。 本版本 Sweep 对适用的非移动空间及 LargeObjectSpace 执行清扫,明确排除 bump_pointer_space;移动空间由 RunPhases 的后续压缩与 FinishPhase 等步骤处理。活跃字段持有数组时,这条强可达路径使它们保持存活;清空 retained/sink 后,若没有其他强保活,才可能在覆盖该对象的收集中被回收。若该轮标记已看见它,或对象不属于本轮代际范围,也可能留待后续收集,不能把字段赋 null 与即时回收画成同一个动作。空间可复用如何进一步影响驻留页,仍要接下面的归还页说明。
上述过程还可在固定提交中定位到 MarkCompact::VisitRoots / MarkObjectNonNullNoPush / RefFieldsVisitor、Object::FastVisitReferences 和 MarkCompact::Sweep / RunPhases;本节只补 retained 这条边的来去,不展开 CMC/UFFD 的全部并发协议。
谁执行 GC 谁可能等待
ART 有 HeapTaskDaemon/TaskProcessor 等维护工作路径。libcore Daemons.java 的 HeapTaskDaemon 调用 VMRuntime.runHeapTasks,Native 再进入 Heap 的 TaskProcessor;按任务请求运行并发 GC 等操作。分配慢路径也可能在当前分配线程中协调一次 blocking GC。看到 GC 日志,不能默认它始终由某一固定 Java 线程完成。
等待已有收集完成时,Heap 明确变更线程状态并使用条件变量:
来源:art/runtime/gc/heap.cc,符号 Heap::WaitForGcToComplete 内的连续原文摘录。
ScopedThreadStateChange tsc(self, ThreadState::kWaitingForGcToComplete);
MutexLock mu(self, *gc_complete_lock_);
return WaitForGcToCompleteLocked(cause, self, /* only_one= */ true);
WaitForGcToCompleteLocked 会在条件仍不满足时等待 gc_complete_cond;唤醒后还要重新检查。应用的“分配耗时”因此可以包含等待、真正分配以及被调度出去的时间。GC 总时间、暂停时间、因 GC 阻塞的时间和 CPU 时间需要分别解释。
清空引用 请求 GC 与归还物理页是三个阶段
System.gc() 的公开契约是建议执行回收。本版本沿 Runtime.nativeGc → JVM_GC 进入 ART,显式 GC 也可能被配置跳过:
来源:art/openjdkjvm/OpenjdkJvm.cc,符号 JVM_GC 内的连续原文摘录。
if (art::Runtime::Current()->IsExplicitGcDisabled()) {
LOG(INFO) << "Explicit GC skipped.";
return;
}
art::Runtime::Current()->GetHeap()->CollectGarbage(/* clear_soft_references */ false);
Heap 收集完成后,不可达对象占用的槽位/空间可供后续分配复用;ART 还可能按 space、collector 与 trim 策略用 madvise 等归还页。复用堆中空闲空间不需要 maps 的区间消失;RSS 下降也不要求 Java 对象地址区间从 maps 中删除。
示例的 200 ms 只是取样间隔,不构成 GC 或 RSS 的时限保证。WeakReference 清除可以辅助判断该 referent 不再被强保活,却不能单独证明所有相关对象都回收、Native 引用都释放或页面已返还给 Kernel。
9.8 Java 线程怎样创建 等待 唤醒与退出
Thread 对象与实际线程不是同一件事
new Thread(...) 首先创建 Java 对象;start() 才请求启动执行。Java Thread 通过 nativePeer 与 ART Thread 关联,ART Thread 又关联 pthread、JNIEnv、线程本地状态和 Linux TID。PID 标识进程,TID 标识具体线程;一个进程可有很多线程,但共用该进程地址空间。
在 Thread_nativeCreate 中,JNI 进入 Thread::CreateNativeThread。后者创建 ART Thread,先用全局 JNI 引用保护 Java peer,并保存关联:
来源:art/runtime/thread.cc,符号 Thread::CreateNativeThread 内的连续原文摘录。
Thread* child_thread = new Thread(is_daemon);
// Use global JNI ref to hold peer live while child thread starts.
child_thread->tlsPtr_.jpeer = env->NewGlobalRef(java_peer);
stack_size = FixStackSize(stack_size);
// Thread.start is synchronized, so we know that nativePeer is 0, and know that we're not racing
// to assign it.
SetNativePeer(env, java_peer, child_thread);
准备栈大小、JNIEnv 和 pthread 属性后,再把 ART 回调交给 pthread_create:
来源:art/runtime/thread.cc,符号 Thread::CreateNativeThread 内的连续原文摘录。
pthread_create_result = pthread_create(&new_pthread,
&attr,
gUseUserfaultfd ? Thread::CreateCallbackWithUffdGc
: Thread::CreateCallback,
child_thread);
CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
nativePeer 不是从 Java 随便打印的对象地址推算出来的,而是在创建时写入的 Native 关联。 创建失败会清理 Global Reference、nativePeer 等已建立资源,并在 Java 侧形成异常;成功后子线程通过 CreateCallback 初始化运行时关联,再调用 Java Thread.run。直接调用 thread.run() 只是当前线程的方法调用。
Bionic 的 pthread_create 负责线程栈/TLS、启动握手和 clone 参数。真正请求 Kernel 创建共享地址空间线程的交接点是:
来源:bionic/libc/bionic/pthread_create.cpp,符号 pthread_create 内的连续原文摘录。
int rc = clone(__pthread_start, child_stack, flags, thread, &(thread->tid), tls, &(thread->tid));
CLONE_VM、CLONE_THREAD、TLS 等标志定义共享关系;clone 返回、子线程开始运行、Java run 开始,是三个不同阶段。ART 的 CreateCallback 与 CreateCallbackWithUffdGc 根据配置选择,不能同时画成串行步骤。
wait 会释放 Monitor 继续运行前还要重新取得它
先对齐附录A的waitDemo。ready是CountDownLatch,只表示等待线程走到准备步骤,不证明它已在Kernel中睡眠。下面两段摘录仅移除公共行首缩进,保留相对缩进、语句与换行。
等待线程在gate内检查条件:
synchronized (gate) {
ready.countDown();
log("waiter before wait");
while (!released && !closing) gate.wait();
log("waiter reacquired monitor; released=" + released);
}
业务通知线程取得同一把gate,先改条件再通知:
synchronized (gate) {
released = true;
gate.notifyAll();
log("notifyAll; monitor still held until block exits");
}
released在gate内读写;closing是volatile退出标记,可见性由volatile保证。 wait返回后重新检查while条件;虚假唤醒、取消与中断按各自路径处理。完整创建、join超时和onDestroy清理见附录A,正常与取消按9.11同轮日志区分。
好比一人按铃时仍握着钥匙,另一人听到声音后,还要等锁释放才能开柜。铃声对应通知,钥匙对应锁的占有;真实线程还需要获得调度并重新取得Monitor,不能把听到铃等同立即执行。
观察等待线程、通知线程和gate的固定位置:条件改变、通知、可运行、调度与重新取锁逐步出现。这里示意一条正常唤醒路径,重排队及取消等分支继续看后文;播放顺序与停留时间不构成调度保证或实测时延。
这里表示一种先进入等待、后通知的情形;若条件已满足,while 可以直接结束。没有调用 wait 不等于通知“丢失”,因为真正传递的是受锁保护的条件。
ART Monitor::Wait 在检查持锁、超时与中断状态后,把无限期等待交给线程自己的条件变量:
来源:art/runtime/monitor.cc,符号 Monitor::Wait 内的连续原文摘录。
if (why == ThreadState::kWaiting) {
self->GetWaitConditionVariable()->Wait(self);
} else {
DCHECK(why == ThreadState::kTimedWaiting || why == ThreadState::kSleeping) << why;
timed_out = self->GetWaitConditionVariable()->TimedWait(self, ms, ns);
Monitor 与条件变量是同一等待过程的不同层次:前者维护 Java 对象锁与等待集合,后者支持当前线程挂起和唤醒。 Linux 的 ART_USE_FUTEXES 分支在释放内部 guard 后执行:
来源:art/runtime/base/mutex.cc,符号 ConditionVariable::WaitHoldingLocks 内的连续原文摘录。
int32_t cur_sequence = sequence_.load(std::memory_order_relaxed);
guard_.ExclusiveUnlock(self);
if (futex(sequence_.Address(), FUTEX_WAIT_PRIVATE, cur_sequence, nullptr, nullptr, 0) != 0) {
// Futex failed, check it is an expected error.
序列值检查帮助处理并发改变;返回后还要重新取 guard、调整等待计数,Monitor 层再恢复对象锁关系。notifyAll 不是“给每个线程调用一次业务回调”,也不保证 FIFO 或立刻抢到 CPU。
读到 Kernel 的排队 仍要读回应用
固定 Kernel 的 futex_wait_queue 设置当前任务状态并入队:
来源:kernel/common/kernel/futex/waitwake.c,符号 futex_wait_queue 内的连续原文摘录。
set_current_state(TASK_INTERRUPTIBLE|TASK_FREEZABLE);
futex_queue(q, hb, current);
满足等待条件且尚未被唤醒时,它进入 schedule;唤醒路径让任务有机会变为可运行,调度器再选择何时运行。ART 的条件变量通知还可能使用 FUTEX_REQUEUE,把等待者转移到锁对应队列,避免同时唤醒后一起争锁。
notifyAll 返回、对象锁释放、Kernel 唤醒、线程获调度、重新取锁、条件满足,是需要分别定位的边界。 InterruptedException 与虚假唤醒都要求应用按契约处理;示例退出时通过 closing、条件释放与 interrupt 共同结束等待。
平台线程的 CreateCallback 在准备完成后调用 Java run,返回后注销 ART Thread:
来源:art/runtime/thread.cc,符号 Thread::CreateCallback 内的连续原文摘录。
// Invoke the 'run' method of our java.lang.Thread.
WellKnownClasses::java_lang_Thread_run->InvokeVirtual<'V'>(self, receiver);
}
}
// Detach and delete self.
Runtime::Current()->GetThreadList()->Unregister(self, /* should_run_callbacks= */ true);
这里的虚拟线程相关分支不是本章显式 new Thread 实验的主路径;它不能与平台线程分支合并为先后步骤。Java run 结束后,ART Thread 还要解除运行时登记、JNI 关联等,再由 pthread/Kernel 完成线程退出。JNI Global Reference 的清理和 Native peer 归零有自己的实现位置;线程结束不等于整个进程地址空间被释放,仍被其他 Java 对象持有的 Thread 对象也可以继续存在。
9.9 内存压力怎样连接 Framework lmkd mmd 与 Kernel
先区分三类失败和两类回收
| 现象或动作 | 谁负责主要决策 | 结果 |
|---|---|---|
| Java 对象分配最终失败 | ART Heap 与分配路径 | 当前调用出现 OutOfMemoryError,是否进程退出取决于异常处理等 |
| 系统低内存下选择结束进程 | 用户空间 lmkd 的策略与进程信息 | 向选中对象发出终止动作,应用不一定有 Java 异常和清理机会 |
| Kernel OOM 处理 | 内核分配与 OOM 策略 | 属于另一套内核选择/处理路径,需内核证据区分 |
| 回收文件页、匿名页换出等 | Kernel mm 与相关后端 | 减少驻留或腾出页,不要求结束整个进程 |
| 回收 Java 对象 | ART GC | 让对象空间可复用,并可能进一步归还页 |
Kernel 回收、压缩、ZRAM 或写回都会消耗时间与资源。即使进程最终没有被结束,线程也可能因 direct reclaim、缺页、I/O 或锁等待而变慢。PSI 描述因资源紧张造成的停滞;它适合说明压力,不替代具体分配栈或单个对象分析。官方 lmkd 说明
Framework 怎样把进程重要性交给 lmkd
Framework 根据组件与进程状态计算重要性。当前实现需从 psc/OomAdjusterImpl 等入口读到 ProcessList;下面保留 ProcessList.setOomAdj 的协议交接,不能用它代替全部优先级计算规则:
来源:frameworks/base/services/core/java/com/android/server/am/ProcessList.java,符号 setOomAdj 内的连续原文摘录。
ByteBuffer buf = ByteBuffer.allocate(4 * 6);
buf.putInt(LMK_PROCPRIO);
buf.putInt(pid);
buf.putInt(uid);
buf.putInt(amt);
buf.putInt(0); // PROC_TYPE_APP
buf.putInt(forLmkdOnly ? 1 : 0);
writeLmkd(buf, null);
这里交出去的是 PID、UID、oomadj 等进程信息,不是 Java 对象列表。 lmkd 接收控制协议后校验进程和参数;非 for_lmkd_only 分支更新 Kernel 可见的 oom_score_adj:
来源:system/memory/lmkd/lmkd.cpp,符号 apply_proc_prio 内的连续原文摘录。
snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", params.pid);
snprintf(val, sizeof(val), "%d", params.oomadj);
if (!writefilestring(path, val, false)) {
ALOGW("Failed to open %s; errno=%d: process %d might have been killed", path, errno,
params.pid);
/* If this file does not exist the process is dead. */
return;
随后注册到用户空间维护的候选结构。数值与生命周期关系需要按该版本策略解释;不能用某个历史 PID 的值推断当前应用一定会被先结束,也不能声称 lmkd 就是按 RSS 最大值无条件排序。
PSI 怎样唤起压力处理
在采用 PSI 的策略分支,lmkd 为 stall 类型、阈值和时间窗口建立监听,再注册事件处理:
来源:system/memory/lmkd/lmkd.cpp,符号 init_mp_psi 内的连续原文摘录。
fd = init_psi_monitor(psi_thresholds[level].stall_type,
psi_thresholds[level].threshold_ms * US_PER_MS,
psi_window_size_ms * US_PER_MS);
if (fd < 0) {
return false;
}
vmpressure_hinfo[level].handler = use_new_strategy ? mp_event_psi : mp_event_common;
epoll 收到事件后,mp_event_psi / __mp_event_psi 结合可用内存、回收、抖动、交换和节流等信息决定后续动作。单次 PSI 信号不等于一次必然的 kill;是否使用该策略,还需要核对产品属性、内核能力和 lmkd 初始化结果。
mmd 是并列维护分支,没有画成 lmkd 每次结束进程前必定调用的函数。
选中进程以后 仍需要处理结束与释放
本版本的 kill_one_process 把选中对象交给 Reaper,并处理请求失败:
来源:system/memory/lmkd/lmkd.cpp,符号 kill_one_process 内的连续原文摘录。
if (!reaper.kill({ pidfd, procp->cgroupfd, pid, uid }, false)) {
stop_wait_for_proc_kill(false);
ALOGE("kill(%d): errno=%d", pid, errno);
/* Delete process record even when we fail to kill so that we don't get stuck on it */
goto out;
}
Reaper 优先按条件处理目标 cgroup,无法采用该方式时有 pidfd 信号分支:
来源:system/memory/lmkd/reaper.cpp,符号 kill_cgroup_or_process 内的连续原文摘录。
return pidfd_send_signal(target.pidfd, SIGKILL, NULL, 0) == 0;
发送 SIGKILL 成功不等于所有内存已经同步归还。 还需要目标任务实际退出;Reaper 对适用情况使用 process_mrelease 等协助回收,并处理失败/完成。进程结束不保证调用 Activity.onDestroy、Java finally 或 JNI_OnUnload。
Kernel do_exit 走到 exit_mm;后者解除当前任务的 mm 关联,再降低地址空间引用:
来源:kernel/common/kernel/exit.c,符号 exit_mm 内的连续原文摘录。
mm_update_next_owner(mm);
trace_android_vh_exit_mm(mm);
mmput(mm);
只有相应引用条件满足,才进一步释放地址空间与页表等。文件、共享缓冲区及其他进程持有的引用有各自生命周期,不能把“目标 PID 不见了”写成所有设备共享资源已经释放。
mmd 做什么 为什么它不等于 lmkd
固定提交的 mmd README将 ZRAM 配置和维护列为主要职责:按系统属性设置 ZRAM,在适用配置下处理写回、重压缩等请求,Framework 可通过 IMmd 发起维护。
Framework 的 memory/ZramMaintenance 在条件满足时调用 IMmd.doZramMaintenanceAsync;mmd 接收入口区分工作队列与直接执行:
来源:system/memory/mmd/src/service.rs,符号 doZramMaintenanceAsync 内的连续原文摘录。
if let Some(work_queue) = &self.work_queue {
work_queue.send_low_prio_work(LowPrioWorkItem::ZramMaintenance);
} else {
do_zram_maintenance_and_stats::<Z, T>(&self.ctx);
}
Ok(())
有 work_queue 时,请求进入低优先级队列;之后由 do_zram_maintenance_and_stats 调 handle_zram_maintenance,按能力、参数和策略处理写回/重压缩并记录结果。排队分支的接口返回不证明维护已经完成;没有工作队列的直接分支也不能画成同样的异步交接。
实际维护最终通过 SysfsZramApi 的具体实现访问 Kernel 接口,例如重压缩命令:
来源:system/memory/mmd/src/zram.rs,符号 recompress 内的连续原文摘录。
std::fs::write(self.root_path.join("recompress"), contents)
这连接的是配置的 ZRAM sysfs 接口,由 Kernel ZRAM 子系统解释命令;读写失败和不支持的维护能力需要各自处理,不能等同于某个 Java 分配请求成功。这里没有为读者执行这些 sysfs 写入。
启用服务、具备 ZRAM 设备、配置对应属性、执行一次维护任务,是不同条件。mmd.zram.enabled、maintenance 相关配置和 zram sysfs 需要各自核对。mmd 不负责替每个 Java 对象执行 GC,也不能因为源码仓库存在就认定本设备已启用它。
本章主实验只读取已有压力和进程状态,不运行内存轰炸器、不改变 ZRAM/cgroup 配置、不故意触发整机回收。真实 lmkd 选择、ZRAM 换入换出和 Kernel OOM 的动态验证仍需独立隔离实验,不能由八兆数组示例代替。
9.10 设备共享内存为什么不能只看 Java 堆
一个小 Java 包装可以关联更大的外部资源
HardwareBuffer 是一个适合连接 Java、Native、HAL 与后端的具体例子。Java 对象保存 Native 关联和清理逻辑;真正的图像缓冲区有尺寸、格式、usage、stride、句柄与后端所有权。width × height × 像素字节数 也不总等于实际分配量,因为还可能有对齐、平面布局和元数据。
示例的 CPU usage 缓冲区没有提交到 Surface,不执行一次完整 GPU 绘制。它用于观察“显式创建外部资源—取得包装—关闭”的生命周期。
从 HardwareBuffer.create 追到 Native 包装
Java 参数检查完成后进入 nCreateHardwareBuffer;Native 失败的返回值被转换为 Java 异常:
来源:frameworks/base/core/java/android/hardware/HardwareBuffer.java,符号 create 内的连续原文摘录。
long nativeObject = nCreateHardwareBuffer(width, height, format, layers, usage);
if (nativeObject == 0) {
throw new IllegalArgumentException("Unable to create a HardwareBuffer, either the " +
"dimensions passed were too large, too many image layers were requested, " +
"or an invalid set of usage flags or invalid format was passed");
}
return new HardwareBuffer(nativeObject);
}
JNI 创建 GraphicBuffer,并检查 initCheck:
来源:frameworks/base/core/jni/android_hardware_HardwareBuffer.cpp,符号 android_hardware_HardwareBuffer_create 内的连续原文摘录。
sp<GraphicBuffer> buffer = new GraphicBuffer(width, height, pixelFormat, layers,
grallocUsage, std::string("HardwareBuffer pid [") + std::to_string(getpid()) +"]");
status_t error = buffer->initCheck();
成功后另建保存 sp<GraphicBuffer> 的包装:
来源:frameworks/base/core/jni/android_hardware_HardwareBuffer.cpp,符号 android_hardware_HardwareBuffer_create 内的连续原文摘录。
GraphicBufferWrapper* wrapper = new GraphicBufferWrapper(buffer);
return reinterpret_cast<jlong>(wrapper);
Java nativeObject 关联的是包装结构,包装又持有 Native GraphicBuffer;它不是图像数据区地址,也不能当成另一个进程里的裸指针。 GraphicBuffer::initWithSize 把请求交给分配器:
来源:frameworks/native/libs/ui/GraphicBuffer.cpp,符号 GraphicBuffer::initWithSize 内的连续原文摘录。
status_t err = allocator.allocate(inWidth, inHeight, inFormat, inLayerCount,
inUsage, &handle, &outStride, mId,
std::move(requestorName));
返回 handle/stride 后再设置 GraphicBuffer 状态。Allocator/Mapper 负责分配、导入和元数据等约定;接口类型、版本与 Binder/本地实现需按实际后端追踪。
SDK Emulator 的 Goldfish 后端与 DMA-BUF 分开读
本工程 Goldfish gralloc 构建声明关联 mesa_goldfish_address_space。其 allocateImpl 使用 Host memory allocator:
来源:device/generic/goldfish/hals/gralloc/allocator.cpp,符号 allocateImpl 内的连续原文摘录。
GoldfishAddressSpaceHostMemoryAllocator hostMemoryAllocator(hasSharedSlots);
LOG_ALWAYS_FATAL_IF(!hostMemoryAllocator.is_opened());
if (hostMemoryAllocator.hostMalloc(&bufferBits, totalMappedAllocationSize)) {
return FAILURE(nullptr);
}
该 Host allocator 在 shared-slots 与非 shared-slots 分支采用不同的申请/claim 步骤,再通过 ping 协议与 Host 协作并映射地址块。协议发送最终有明确的 ioctl 入口:
来源:external/mesa3d/src/gfxstream/guest/GoldfishAddressSpace/goldfish_address_space.cpp,符号 ioctl_ping 内的连续原文摘录。
return ::ioctl(fd, GOLDFISH_ADDRESS_SPACE_IOCTL_PING, request);
虚拟设备模块的 as_ioctl 根据命令分派:
来源:kernel/common-modules/virtual-device/goldfish_drivers/goldfish_address_space.c,符号 as_ioctl 内的连续原文摘录。
case GOLDFISH_ADDRESS_SPACE_IOCTL_PING:
res = as_ioctl_ping(file_state, (void __user *)arg);
break;
这一段读到了 Goldfish guest Driver 的协议入口,Host 分配实现和实际运行分支还需要对应的运行器证据。 仅有节点打开记录,不能证明这次 HardwareBuffer 执行了相同分配调用。本章未运行此示例,实际分支仍需按9.11核对;Host 预编译包的精确实现,以及物理设备上的 DMA-BUF/GPU Driver,还需另选对应材料。
观察Java关联怎样指向Native包装,再看包装持有的GraphicBuffer与实际后端。Goldfish和DMA-BUF是备选实现;close先结束本持有者责任,只有其他持有和同步条件也满足时才可能最终释放。图中的额外持有者是条件示意,不是本例已经共享缓冲区的实测。
两条后端边是备选实现,不能串成“Goldfish 接着必经 dma_heap”的调用链。
DMA-BUF 解释共享责任 不替代实际设备选择
在采用 DMA-BUF 的后端,exporter 管理缓冲区主体,dma_buf 表示共享对象,fd 是某个进程持有它的文件描述符;importer/attachment 和 GPU 映射又是不同关系。内核 dma_buf_fd 为当前进程安装描述符:
来源:kernel/common/drivers/dma-buf/dma-buf.c,符号 dma_buf_fd 内的连续原文摘录。
fd = get_unused_fd_flags(flags);
if (fd < 0)
return fd;
fd_install(fd, dmabuf->file);
复制或跨进程传递 fd 会建立新的有效引用,不是搬走整个图像字节。Java 堆统计只看到包装对象的那部分;Native 分配器统计也未必覆盖 exporter 管理的全部页。
close 只完成本持有者的责任
HardwareBuffer.close 清空 Native 关联并运行注册的清理动作:
来源:frameworks/base/core/java/android/hardware/HardwareBuffer.java,符号 close 内的连续原文摘录。
if (!isClosed()) {
mCloseGuard.close();
mNativeObject = 0;
mCleaner.run();
mCleaner = null;
}
JNI 的 wrapper 销毁使其 sp<GraphicBuffer> 减少持有,GraphicBuffer/Mapper/HAL 再按引用关系归还资源。在 DMA-BUF 方案中,最终文件对象释放会回到 exporter 的 release 回调:
来源:kernel/common/drivers/dma-buf/dma-buf.c,符号 dma_buf_release 内的连续原文摘录。
dma_buf_stats_teardown(dmabuf);
dmabuf->ops->release(dmabuf);
本次 Java close 不保证其他进程、fd、GPU 作业或导入者已放弃它们的持有。 在途设备工作还涉及 fence 等同步;进程退出也要按这些引用条件看结果。Android Bitmap、媒体帧、DMA-BUF、HardwareBuffer 的内存计费与生命周期不能统一归成“Java GC 会自动全部收回”。
9.11 按问题组合日志 maps meminfo 与 Trace
先保留每一步前后的同轮快照
以下命令在前面已初始化变量的 Host 终端 A 的 Bash 中执行。启动示例后重新获取 PID;多个 PID、空值或格式异常时先停止本步骤核实进程,避免把进程重建前后的数据拼在一起。
read -r -a ch9_pids <<< "$("$ch9_adb" -s "$ch9_serial" shell pidof com.example.memorydemo | tr -d '\r')"
if [ "${#ch9_pids[@]}" -ne 1 ] || ! [[ "${ch9_pids[0]:-}" =~ ^[1-9][0-9]*$ ]]; then
printf '本轮PID输出无效(匹配数=%s),先核实进程,停止采集。\n' "${#ch9_pids[@]}" >&2
exit 1
fi
ch9_pid="${ch9_pids[0]}"
"$ch9_adb" -s "$ch9_serial" shell dumpsys meminfo com.example.memorydemo \
> "$ch9_run/meminfo-before.txt"
"$ch9_adb" -s "$ch9_serial" shell run-as com.example.memorydemo \
cat "/proc/$ch9_pid/maps" > "$ch9_run/maps-before.txt"
"$ch9_adb" -s "$ch9_serial" shell run-as com.example.memorydemo \
cat "/proc/$ch9_pid/status" > "$ch9_run/status-before.txt"
run-as 要求 debuggable、包已安装且设备策略允许;它启动的是辅助进程,所以明确读取目标 PID 的文件,不能误用辅助进程自己的 /proc/self/status 当作应用快照。权限失败时先保留错误,dumpsys 能提供另一种观察,但两者字段并不完全等价。
每次“保留”“短命”或“清除”动作结束后,重复上面的 PID 核对与三条采集命令,并把三处输出文件名里的 before 改为对应的 after-retain、after-churn 或 after-release。例如保留后保存为 meminfo-after-retain.txt、maps-after-retain.txt、status-after-retain.txt。若 PID 变化,本次前后对照作废,重新保存 before 再运行单项动作。记录按钮对应的日志时间、PID/TID 与 Trace 区间,不只保留一张数字截图。
| 想回答的问题 | 首先看什么 | 再核对什么 |
|---|---|---|
| 活跃 Java 对象是否增加 | javaUsed、Heap Dump 中字段到数组的保留路径 | GC 是否发生、对象是否还被其他 Root 保活 |
| 进程驻留是否增加 | status 的 VmRSS、meminfo/PSS、可访问时的 smaps_rollup | 匿名/文件/共享、Swap 等分类与采样时刻 |
| maps 为什么没变 | 映射区间、权限、名称 | 原空间复用或 madvise 归还,不要求解除整个映射 |
| 某段调用为什么很慢 | 应用 Trace 与线程状态 | Running、Runnable、Sleeping、GC 暂停/分配等待分别占多少 |
| 后台进程为什么消失 | 同轮 lmkd/ActivityManager 日志、退出原因、Kernel 证据 | 区分手动停止、崩溃、lmkd 与 Kernel OOM |
| 图形内存去了哪里 | buffer 生命周期、fd/handle、Allocator/Mapper 身份 | 实际 exporter/后端、共享引用、同步与计费口径 |
采集一段能同时看到应用和调度的 Trace
同篇附录B的Perfetto配置采集 20 秒,包含应用自定义 Trace、dalvik 类别、线程调度和系统内存统计。配置没有假定所有缺页/PSI tracepoint 都存在;要追某个 Kernel 函数,应先核对该设备事件与权限,再单独扩展。
"$ch9_adb" -s "$ch9_serial" push \
"$ch9_chapter/示例/追踪配置/第九章ART与Memory.pbtxt" \
/data/local/tmp/chapter9-memory.pbtxt
"$ch9_adb" -s "$ch9_serial" shell perfetto --txt \
-c /data/local/tmp/chapter9-memory.pbtxt \
-o /data/misc/perfetto-traces/chapter9-memory.perfetto-trace \
> "$ch9_run/perfetto-capture.txt" 2>&1 &
ch9_capture_pid=$!
等待命令开始采集后,在设备上按一次“wait 与 notifyAll”或一次“短命对象”,不要同时混入多个变量;20 秒后在同一终端收尾:
wait "$ch9_capture_pid"
"$ch9_adb" -s "$ch9_serial" pull \
/data/misc/perfetto-traces/chapter9-memory.perfetto-trace \
"$ch9_run/chapter9-memory.perfetto-trace"
test -s "$ch9_run/chapter9-memory.perfetto-trace"
采集成功、文件非空和采到目标动作仍是不同判据。在 Perfetto UI 打开文件,找 Chapter9:* 区间,也可用附录B的查询应用区间.sql。本文尚未采集真实 Trace。
读 wait 实验时,应观察等待线程有无 Sleeping、何时被唤醒、唤醒后何时 Running;应用外层区间包含整个等待时长,不能全部当成 CPU 时间。要区分该线程的执行与等待,可在同一 TID、同一时间窗内合计 Running 片段;Runnable 只表示等待调度。GC 的某个大区间也可能包含并发阶段,需结合其他线程和暂停片段判断。
把 wait 的正常完成与两种取消分开验收
每轮只点一次 wait 按钮,按同一 PID、这次点击的时间窗及各日志的 TID 关联:waiter before wait 来自等待线程,notifyAll; monitor still held until block exits 来自业务通知线程,外层 before/after 快照来自工作线程。清理用的 finally 也会设置 released=true 并 notifyAll,因此一条 waiter reacquired monitor; released=true 不能独立证明业务通知实验正常完成。
| 本轮结果 | 日志与操作判据 | 怎样记录 |
|---|---|---|
| 正常完成 | 同轮依次出现 waiter before wait → 业务 notifyAll → 同一等待线程的 waiter reacquired monitor; released=true,随后外层 after 快照;该动作窗口内没有 join timed out、相关 interrupted 或 closing 退出取消 | 可记本轮正常通知与等待返回;仍用 Trace 区分唤醒、调度和重新取锁,不承诺固定时延 |
| join 超时后取消 | 出现 join timed out; cancel pair;例如 ready.await 超时会让通知线程返回,等待线程仍活着时 join 检查会报告取消 | 该轮不是正常通知通过;finally 随后的 notifyAll/interrupt 可能产生 reacquired released=true 或 waiter interrupted,保留为取消结果 |
| 页面退出后取消 | 执行到示例 onDestroy 时先出现 closing: cancel wait pair and pending work,随后释放条件、中断等待线程并停止队列;可能看到 waiter interrupted、外层 interrupted,或因条件已释放而看到 reacquired released=true | 记为退出取消,取消路径不要求每条中断日志都出现;即使后来出现 after 或 released=true,也不能据此改判正常通知 |
超时和退出可以在同一轮相遇,任一取消证据出现,就保留完整时间窗并把正常通知实验记为无效;待旧任务/线程收尾后重新关联一次点击,不把两轮日志拼接。本表的退出取消限定为退出发生在该步骤尚未结束时,正常完成之后离开页面不追溯改变前一轮结果。外层 after 快照只说明外层步骤返回,当前示例在超时取消后也可能打印它。若进程被直接结束而未执行 onDestroy,可能没有 closing 日志,应按实际进程退出记录另判,不能用“没有 closing”反推一定正常。
读取系统压力与维护身份
以下只读命令不设置阈值、不修改属性和 cgroup:
"$ch9_adb" -s "$ch9_serial" shell cat /proc/meminfo > "$ch9_run/system-meminfo.txt"
"$ch9_adb" -s "$ch9_serial" shell cat /proc/pressure/memory > "$ch9_run/memory-psi.txt"
"$ch9_adb" -s "$ch9_serial" shell cat /proc/swaps > "$ch9_run/swaps.txt"
"$ch9_adb" -s "$ch9_serial" shell getprop mmd.zram.enabled
"$ch9_adb" -s "$ch9_serial" shell pidof lmkd
"$ch9_adb" -s "$ch9_serial" shell pidof mmd
"$ch9_adb" -s "$ch9_serial" shell run-as com.example.memorydemo \
cat "/proc/$ch9_pid/oom_score_adj"
"$ch9_adb" -s "$ch9_serial" shell run-as com.example.memorydemo \
cat "/proc/$ch9_pid/cgroup"
没有 PSI 文件可能是内核能力或挂载/权限差异;mmd 属性为空或没有 PID 需要继续核对产品配置,不能据此说所有系统都没有 ZRAM。PSI some 表示至少部分任务受阻,full 描述相关条件下所有非空闲任务受阻;窗口平均值与 total 累计时间分别读取。
前台/后台对照可先采集当前 oom_score_adj,再在设备按 Home,重新确认 PID 与相同字段。字段变化只说明这次进程信息变化,没有证明 lmkd 刚刚结束了哪个对象。 不用 am force-stop 伪装低内存回收,也不把停进程命令当成 Java GC 测试。
HardwareBuffer 后端还需补什么证据
查询服务与配置可从下面开始:
"$ch9_adb" -s "$ch9_serial" shell service list > "$ch9_run/services.txt"
"$ch9_adb" -s "$ch9_serial" shell getprop ro.hardware.gralloc
"$ch9_adb" -s "$ch9_serial" shell getprop ro.boot.hardware.gltransport
"$ch9_adb" -s "$ch9_serial" shell ls -l /dev/goldfish_address_space
Allocator 服务名、Mapper 加载实现、VINTF、进程 fd 与本轮请求需进一步关联。service list 是起点,不包含所有进程内加载的实现。图形 fd 或某个模块存在只证明材料/入口存在;若要证明 buffer 本体走了 DMA-BUF,还必须定位 fd 对应对象、exporter 与实际分配请求。本章未取得这部分本轮证据。
失败案例应该怎样记录
| 现象 | 先保留的证据 | 排查方向 |
|---|---|---|
| ClassNotFoundException | 类名、ClassLoader、路径与 suppressed exceptions | 包名、DEX 输入、委派与依赖,不先猜内核 |
| 初始化失败 | 首次异常 cause、clinit 日志、线程 | 静态块、依赖初始化和错误状态 |
| OutOfMemoryError | 完整信息、请求大小、Java 上限、当时内存快照 | 托管堆、Native/线程资源、碎片与地址空间分别判断 |
| GC 后 RSS 不降 | 同轮 javaUsed、GC、maps、RSS/PSS | 其他引用、space 保留复用、归还策略和其他内存类别 |
| 等待线程没有继续 | 条件值、持锁者、通知/中断/Trace | 锁尚未释放、调度、重新竞争与应用条件 |
| HardwareBuffer 创建异常 | 尺寸、格式、usage、Allocator 返回与后端日志 | 不支持组合、分配失败、句柄/导入问题 |
本表给出排查入口,不表示本次发生过这些故障。实际记录保留设备/源码身份、现象、同轮证据、原因及置信边界、修复与复核;未确认的原因单列为推断。
9.12 回顾 自测 源码速查与验证边界
回到开头那几个没有一起下降的数字,先沿着数组追问:它是否仍被强保活?本轮收集覆盖它了吗?对象位置能否复用,页又是否归还?最后,再确认自己读的是哪一种统计。分析线程等待与外部缓冲区时,也用同样的方法,分清通知、执行、结束本持有者责任与最终释放。
用五条链重建本章
- 类型与执行:类名、加载器和 DEX 形成类型关联;初始化执行 clinit;方法入口按解释、编译、桥接或 JNI 路径继续,并返回结果或异常。
- 对象与页:ART 分配器先利用现有空间;需要时建立映射,访问某页时才可能触发缺页;GC 回收对象空间与 Kernel 页回收有不同粒度和时机。
- 线程与等待:Java Thread 关联 ART Thread,经 pthread/clone 启动;wait 释放 Monitor 后可能在 futex 等待,通知、重新调度与重新取锁分别发生。
- 系统压力:Framework 提供进程重要性,lmkd 结合压力和策略选择动作;mmd 维护 ZRAM 的配置与任务;结束进程后的资源归还仍受引用与退出路径约束。
- 设备缓冲区:Java 包装经 JNI 关联 Native GraphicBuffer,再按真实 Allocator/Mapper 走 Goldfish 或其他设备后端;fd、导入、设备工作与最终释放要分别追踪。
自测 先回答再核对
- 一个应用进程的所有内存都属于 ART Heap 吗?
- initialize=false 的 Class.forName 与 new 对象,有哪些不同?
- 两个 ClassLoader 返回同名类,为什么仍可能无法强转?
- 为什么不能用 ArtMethod::Invoke 代表所有 Java 方法调用?
- new byte 数组一定执行 mmap 吗?一个数组一定对应一页吗?
- TLAB 指针增加和 RSS 增加是什么关系?
- GC 后弱引用清除了,为什么 PSS 仍可能不下降?
- GC 总时间和应用暂停时间为什么不同?
new Thread、start、run与 Kernel clone 怎样区分?- notifyAll 后等待线程为什么还可能没有运行?
- Java OOME、lmkd 回收、Kernel OOM 怎样收集证据区分?
- mmd 是否必须在 lmkd 之前执行一次维护?
- HardwareBuffer.close 为什么不能保证所有设备内存立即归还?
- 仅用 adb 注入、force-stop 或短命数组,能否证明所有 Kernel/Driver 链路已验证?
参考答案:
- 还包括 Native 分配、映射文件、代码缓存、栈、运行时元数据与可能的外部缓冲区。见 9.1。
- 前者请求找到 Class 而不要求初始化;创建实例要满足初始化与实例分配/构造条件。成功初始化可缓存。见 9.4。
- 类型身份包含定义加载器;同名不保证同一类型。见 9.4。
- 它是可定位的 runtime 调用入口之一;直接编译调用、内联、解释器等有其他入口。见 9.5。
- 先尝试现有堆空间;对象大小、页粒度、对齐、COW/大页等没有一一对应关系。见 9.6。
- 已有有效页中的分配可以只推进用户空间指针;新页访问才可能改变驻留情况。见 9.6。
- 弱引用只观察该对象的强可达性;space 可保留复用,进程还有其他映射/共享页及计费变化。见 9.7。
- 并发阶段与暂停交替,还要区分分配等待、调度等待和 CPU 时间。见 9.7~9.8。
- 创建 Java 对象不等于新建线程;start 才沿 Native 创建路径,直接 run 在调用线程执行。见 9.8。
- 通知线程可能仍持锁,等待线程还要获调度、重新取锁并检查条件。见 9.8。
- 分别保留 ART 异常分配上下文、lmkd 选择/终止日志、Kernel OOM/退出证据;时间与 PID 属于同轮。见 9.9~9.11。
- 两者职责与策略并列,取决于能力和配置,没有统一的必然串行关系。见 9.9。
- 它只释放本包装所持资源;其他 fd、导入者和在途设备工作仍可能持有。见 9.10。
- 不能。它们只覆盖对应入口/动作;完整路径需要真实后端与该次运行证据。见 9.11。
按问题查关键符号
| 要追什么 | 文件或符号 |
|---|---|
| 委派与自己的 DEX | ClassLoader.loadClass、BaseDexClassLoader.findClass、DexPathList.findClass |
| Native 定义与初始化 | DexFile_defineClassNative、ClassLinker::DefineClass / InitializeClass |
| 方法执行与 JIT | ArtMethod::Invoke、Jit::MaybeEnqueueCompilation / CompileMethod |
| Native 库装载 | Runtime.nativeLoad、JVM_NativeLoad、JavaVMExt::LoadNativeLibrary、NativeLoader、linker_phdr |
| 对象分配与重试 | Array::Alloc、Heap::AllocObjectWithAllocator / AllocateInternalWithGc、Thread::AllocTlab |
| 映射与缺页 | BumpPointerSpace/RegionSpace、MemMap、Kernel do_mmap / do_anonymous_page |
| 收集与等待 | CollectGarbageInternal、MarkCompact::RunPhases、WaitForGcToComplete |
| 线程创建与等待 | Thread::CreateNativeThread、Bionic pthread_create、Monitor::Wait、ConditionVariable::WaitHoldingLocks |
| Kernel 等待与退出 | futex_wait_queue、futex_wake、exit_mm |
| 压力与优先级 | psc/OomAdjusterImpl、ProcessList.setOomAdj、lmkd apply_proc_prio / init_mp_psi / kill_one_process、Reaper |
| ZRAM 维护 | system/memory/mmd README、IMmd、src/zram 与产品属性 |
| 图形包装与后端 | HardwareBuffer.create/close、GraphicBuffer::initWithSize、Goldfish allocateImpl、hostMalloc、as_ioctl |
| DMA-BUF 所有权 | dma_buf_fd、dma_buf_release、exporter 的 release |
固定提交与来源
本章源码摘录来自以下固定项目提交。找到对应源码,不代表设备已经执行该分支。Kernel 与虚拟设备模块使用公开固定提交文件,不把临时下载目录当成设备当前源码构建树。
| 项目 | 固定提交 |
|---|---|
| art | b753cf97923c3695338d21466fa14c57b480a59a |
| libcore | 4ebfb391ee0109d16abe6e2bc965724b940928c5 |
| bionic | 06356e41c5ed7b12220b24c05ba4fdb873b126a7 |
| frameworks/base | 94b4c163b7dfe5ce3607f7bb8456f9573f7de57d |
| frameworks/native | ae266dcb706d083868578cfedce381ef44488a07 |
| system/memory/lmkd | c3601e823bd07c9c190f67e2f9bc7486e4978328 |
| system/memory/mmd | cf66bc31a4002e6f786da7c5a45e4088d19530ed |
| device/generic/goldfish | 296e55aa0244e8929e393e00e34471fef2a5d662 |
| external/mesa3d | 875160ed32cc5bc32777fa04870a0a57ed38c987 |
| kernel/common | ccafb60de224d35a8bc14de33e1cd47caaaa786b |
| kernel/common-modules/virtual-device | 544e91ec0222069e5477857d16614b453e137340 |
概念与契约延伸阅读:ART、JIT、GC 调试、JNI、lmkd。官方概览也有特定年代的描述;实际 collector 和执行分支仍以所选源码及设备配置为准。
附录A 保存完整示例与构建脚本
本附录对应9.3:在Host终端A已设置ch9_chapter后,先准备目录,再按下面相对路径保存UTF-8文件,回9.3构建。复制时按完整代码块保存;屏幕自动折行不是额外回车,保留反斜杠、引号与原有换行。
mkdir -p "$ch9_chapter/示例/Chapter9MemoryDemo/src/com/example/memorydemo"
mkdir -p "$ch9_chapter/示例/追踪配置"
下面文件名均相对于 $ch9_chapter/示例/。Android.bp.example只用于可选Soong,独立构建器不读取该模板。工具依赖包括JDK的java/javac/jar、Host aidl/aapt2、D8、signapk、SDK android.jar、相关Host库和测试密钥;缺项由脚本列出,输出目录须为空。规模有界仍不保证任何设备条件下都分配成功。
Chapter9MemoryDemo/AndroidManifest.xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.memorydemo">
<uses-sdk android:minSdkVersion="28" />
<application android:label="ART Memory Demo" android:debuggable="true"
android:theme="@android:style/Theme.Material.Light.NoActionBar">
<activity android:name=".MainActivity" android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Chapter9MemoryDemo/Android.bp.example
android_app {
name: "Chapter9MemoryDemo",
manifest: "AndroidManifest.xml",
srcs: ["src/**/*.java"],
sdk_version: "current",
min_sdk_version: "28",
certificate: "testkey",
optimize: { enabled: false },
}
Chapter9MemoryDemo/src/com/example/memorydemo/LazyPayload.java
package com.example.memorydemo;
import android.os.Process;
import android.util.Log;
public final class LazyPayload {
static {
Log.i("Chapter9Memory", "LazyPayload.<clinit> pid=" + Process.myPid()
+ " tid=" + Process.myTid());
}
public LazyPayload() {}
public int add(int a, int b) {
return a + b;
}
}
Chapter9MemoryDemo/src/com/example/memorydemo/MainActivity.java
package com.example.memorydemo;
import android.app.Activity;
import android.hardware.HardwareBuffer;
import android.os.Bundle;
import android.os.Debug;
import android.os.Process;
import android.os.Trace;
import android.util.Log;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.ScrollView;
import android.widget.TextView;
import java.lang.ref.WeakReference;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;
/** 教学示例:所有规模有界;不制造系统级 OOM,不改运行时或系统属性。 */
public final class MainActivity extends Activity {
private static final String TAG = "Chapter9Memory";
private final ExecutorService worker = Executors.newSingleThreadExecutor();
private final Object gate = new Object();
private volatile boolean closing;
private boolean released;
private volatile Thread waiter;
private volatile Thread notifier;
// 业务由 worker 读写;主线程退出时也可清空,finally 处理在途任务。
private volatile byte[][] retained;
private volatile Object sink;
private volatile WeakReference<byte[]> watched;
private TextView status;
private interface Step { void run() throws Exception; }
@Override public void onCreate(Bundle state) {
super.onCreate(state);
LinearLayout layout = new LinearLayout(this);
layout.setOrientation(LinearLayout.VERTICAL);
status = new TextView(this);
layout.addView(status);
addButton(layout, "1 类加载与初始化", this::loadClassDemo);
addButton(layout, "2 保留 8 MiB 并写入", this::retainDemo);
addButton(layout, "3 产生有界短命对象", this::churnDemo);
addButton(layout, "4 清除引用并请求 GC", this::releaseDemo);
addButton(layout, "5 wait 与 notifyAll", this::waitDemo);
addButton(layout, "6 HardwareBuffer 创建与关闭", this::bufferDemo);
addButton(layout, "7 当前内存快照", () -> snapshot("manual"));
ScrollView scroll = new ScrollView(this);
scroll.addView(layout);
setContentView(scroll);
log("created; pid=" + Process.myPid() + "; 按按钮运行单项实验");
}
private void addButton(LinearLayout layout, String name, Step step) {
Button button = new Button(this);
button.setText(name);
button.setOnClickListener(v -> {
if (closing) return;
try {
worker.execute(() -> {
if (closing) return;
Trace.beginSection("Chapter9:" + name);
try {
snapshot("before " + name);
step.run();
snapshot("after " + name);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log("interrupted " + name);
} catch (Exception e) {
Log.e(TAG, "failed " + name, e);
log(e.getClass().getSimpleName() + ": " + e.getMessage());
} finally {
if (closing) { retained = null; sink = null; watched = null; }
Trace.endSection();
}
});
} catch (RejectedExecutionException e) {
if (!closing) throw e;
}
});
layout.addView(button);
}
private void loadClassDemo() throws Exception {
String name = "com.example.memorydemo.LazyPayload";
ClassLoader loader = getClassLoader();
Class<?> loaded = Class.forName(name, false, loader);
log("loaded, initialize=false; loader=" + loaded.getClassLoader());
Class.forName(name, true, loader);
Object instance = loaded.getDeclaredConstructor().newInstance();
Object result = loaded.getMethod("add", int.class, int.class).invoke(instance, 7, 8);
log("initialized, reflective add=" + result);
try {
Class.forName("com.example.memorydemo.DoesNotExist", false, loader);
} catch (ClassNotFoundException expected) {
log("expected ClassNotFoundException");
}
}
private void retainDemo() throws InterruptedException {
Runtime runtime = Runtime.getRuntime();
long freeBudget = runtime.maxMemory() - (runtime.totalMemory() - runtime.freeMemory());
if (freeBudget < 32L * 1024 * 1024) {
log("remaining Java heap budget < 32 MiB; skip retained allocation");
return;
}
byte[][] next = new byte[32][];
for (int i = 0; i < next.length; i++) {
if (closing || Thread.currentThread().isInterrupted()) throw new InterruptedException();
next[i] = new byte[256 * 1024];
// 每个字节均写入;不依赖设备页大小,也不宣称逐一观察到缺页。
java.util.Arrays.fill(next[i], (byte) (i + 1));
}
retained = next;
watched = new WeakReference<>(next[0]);
log("retained payload=8388608 bytes; previous retained array replaced");
}
private void churnDemo() throws InterruptedException {
Object[] ring = new Object[64];
for (int i = 0; i < 8192; i++) {
if (closing || Thread.currentThread().isInterrupted()) throw new InterruptedException();
byte[] data = new byte[4096];
data[0] = (byte) i;
ring[i % ring.length] = data;
}
sink = ring;
log("churn payload=32 MiB total; only last 64 arrays held by sink");
}
private void releaseDemo() throws InterruptedException {
retained = null;
sink = null;
System.gc();
Thread.sleep(200);
WeakReference<byte[]> current = watched;
log("weak reference cleared=" + (current != null && current.get() == null)
+ "; no guarantee about GC completion or RSS");
}
private void waitDemo() throws InterruptedException {
CountDownLatch ready = new CountDownLatch(1);
synchronized (gate) { released = false; }
Thread localWaiter = new Thread(() -> {
Trace.beginSection("Chapter9:waiter");
try {
synchronized (gate) {
ready.countDown();
log("waiter before wait");
while (!released && !closing) gate.wait();
log("waiter reacquired monitor; released=" + released);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log("waiter interrupted");
} finally { Trace.endSection(); }
}, "Chapter9Waiter");
Thread localNotifier = new Thread(() -> {
try {
if (!ready.await(1, TimeUnit.SECONDS) || closing) return;
Thread.sleep(200);
synchronized (gate) {
released = true;
gate.notifyAll();
log("notifyAll; monitor still held until block exits");
}
} catch (InterruptedException e) { Thread.currentThread().interrupt(); }
}, "Chapter9Notify");
waiter = localWaiter;
notifier = localNotifier;
try {
if (closing) return;
localWaiter.start();
localNotifier.start();
localWaiter.join(2000);
localNotifier.join(2000);
if (localWaiter.isAlive() || localNotifier.isAlive()) log("join timed out; cancel pair");
} finally {
synchronized (gate) { released = true; gate.notifyAll(); }
localWaiter.interrupt();
localNotifier.interrupt();
waiter = null;
notifier = null;
}
}
private void bufferDemo() {
long usage = HardwareBuffer.USAGE_CPU_READ_OFTEN | HardwareBuffer.USAGE_CPU_WRITE_OFTEN;
try (HardwareBuffer buffer = HardwareBuffer.create(128, 128,
HardwareBuffer.RGBA_8888, 1, usage)) {
log("HardwareBuffer " + buffer.getWidth() + "x" + buffer.getHeight()
+ "; isClosed=" + buffer.isClosed());
}
log("HardwareBuffer.close completed; no frame submitted to GPU/display");
}
private void snapshot(String point) {
Runtime r = Runtime.getRuntime();
log(point + " javaUsed=" + (r.totalMemory() - r.freeMemory())
+ " javaTotal=" + r.totalMemory() + " javaMax=" + r.maxMemory()
+ " nativeAllocated=" + Debug.getNativeHeapAllocatedSize()
+ " pssKiB=" + Debug.getPss()
+ " gcCount=" + Debug.getRuntimeStat("art.gc.gc-count"));
}
private void log(String message) {
String text = "pid=" + Process.myPid() + " tid=" + Process.myTid() + " " + message;
Log.i(TAG, text);
if (!closing) runOnUiThread(() -> { if (!closing) status.setText(text); });
}
@Override protected void onDestroy() {
closing = true;
log("closing: cancel wait pair and pending work");
synchronized (gate) { released = true; gate.notifyAll(); }
Thread w = waiter;
Thread n = notifier;
if (w != null) w.interrupt();
if (n != null) n.interrupt();
worker.shutdownNow();
retained = null;
sink = null;
watched = null;
// 在途任务若随后写入字段,其 finally 会因 closing 再次清理。
super.onDestroy();
}
}
构建示例APK.py
#!/usr/bin/env python3
"""用已构建的 AOSP Host 工具打包本章无资源示例,不修改系统镜像。"""
import argparse
import json
from pathlib import Path
import subprocess
import zipfile
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--aosp-top", type=Path, required=True)
parser.add_argument("--module", type=Path, required=True)
parser.add_argument("--name", required=True)
parser.add_argument("--out", type=Path, required=True)
parser.add_argument("--target-sdk", default="36")
args = parser.parse_args()
top = args.aosp_top.resolve()
module = args.module.resolve()
output = args.out.resolve()
if not (module / "AndroidManifest.xml").is_file():
parser.error("module 需要指向包含 AndroidManifest.xml 的示例目录")
if output.exists() and any(output.iterdir()):
parser.error("out 目录需为空;请为本轮构建使用新目录")
output.mkdir(parents=True, exist_ok=True)
host = top / "out/host/linux-x86"
sdk = top / "prebuilts/sdk/current/public/android.jar"
java = top / "prebuilts/jdk/jdk21/linux-x86/bin/java"
javac = java.with_name("javac")
jar = java.with_name("jar")
required = [host / "bin/aidl", host / "bin/aapt2", host / "framework/d8.jar",
host / "framework/signapk.jar", sdk, java, javac, jar,
host / "lib64/libconscrypt_openjdk_jni.so",
top / "build/make/target/product/security/testkey.x509.pem",
top / "build/make/target/product/security/testkey.pk8"]
missing = [str(path) for path in required if not path.is_file()]
if missing:
parser.error("缺少已构建的 Host 工具或材料:\n" + "\n".join(missing))
commands = []
def run(command):
command = [str(value) for value in command]
subprocess.run(command, check=True, cwd=top)
commands.append(command)
generated, classes, dex = [output / name for name in ("generated", "classes", "dex")]
for directory in (generated, classes, dex):
directory.mkdir()
for aidl in sorted((module / "src").rglob("*.aidl")):
run([host / "bin/aidl", "--lang=java", "--min_sdk_version=28",
"-I", module / "src", "-o", generated, aidl])
sources = sorted((module / "src").rglob("*.java")) + sorted(generated.rglob("*.java"))
run([javac, "--release", "17", "-cp", sdk, "-d", classes, *sources])
run([jar, "cf", output / "classes.jar", "-C", classes, "."])
run([java, "-cp", host / "framework/d8.jar", "com.android.tools.r8.D8",
"--lib", sdk, "--min-api", "28", "--output", dex, output / "classes.jar"])
run([host / "bin/aapt2", "link", "-I", sdk, "--manifest", module / "AndroidManifest.xml",
"--min-sdk-version", "28", "--target-sdk-version", args.target_sdk,
"-o", output / "unsigned.apk"])
with zipfile.ZipFile(output / "unsigned.apk", "a", zipfile.ZIP_DEFLATED) as archive:
for path in sorted(dex.glob("*.dex")):
archive.write(path, path.name)
apk = output / (args.name + ".apk")
run([java, "-Djava.library.path=" + str(host / "lib64"), "-jar",
host / "framework/signapk.jar",
top / "build/make/target/product/security/testkey.x509.pem",
top / "build/make/target/product/security/testkey.pk8", output / "unsigned.apk", apk])
(output / "build-commands.json").write_text(json.dumps(commands, ensure_ascii=False, indent=2))
print(apk)
if __name__ == "__main__":
main()
不再需要示例时,可在选定设备的Host终端卸载;这会删除示例数据,Host日志不会随之删除:
"$ch9_adb" -s "$ch9_serial" uninstall com.example.memorydemo
附录B 保存Trace配置与查询
本附录对应9.11,保存到 $ch9_chapter/示例/追踪配置/。配置采集20秒,SQL查Chapter9区间;仍需结合线程状态解释等待与运行。
追踪配置/第九章ART与Memory.pbtxt
buffers: { size_kb: 32768 fill_policy: RING_BUFFER }
duration_ms: 20000
data_sources: {
config {
name: "linux.ftrace"
ftrace_config {
ftrace_events: "sched/sched_switch"
ftrace_events: "sched/sched_waking"
ftrace_events: "sched/sched_process_exit"
atrace_categories: "dalvik"
atrace_apps: "com.example.memorydemo"
}
}
}
data_sources: { config { name: "linux.process_stats" process_stats_config { scan_all_processes_on_start: true } } }
data_sources: { config { name: "linux.sys_stats" sys_stats_config { meminfo_period_ms: 250 vmstat_period_ms: 250 } } }
追踪配置/查询应用区间.sql
SELECT p.pid, t.tid, t.name AS thread_name, s.name,
s.ts / 1e6 AS start_ms, s.dur / 1e6 AS duration_ms
FROM slice s
JOIN thread_track tt ON tt.id = s.track_id
JOIN thread t ON t.utid = tt.utid
LEFT JOIN process p ON p.upid = t.upid
WHERE s.name GLOB 'Chapter9:*'
ORDER BY s.ts;