Android源码第九章:ART 与内存管理——跟着一个对象走到物理页与回收

51 阅读22分钟

清空一批数组,调用 System.gc(),再看进程内存:为什么几个数字没有一起下降?继续创建对象时,有时分配很快,有时线程却会停下来。应用退到后台后,还可能没有抛 Java OutOfMemoryError 就被系统结束。

理解这些现象,需要区分三个尺度:ART 管对象,Kernel 管地址空间和页,Android 按系统压力管理进程。 本章从同一个有界示例出发,先加载类和执行方法,再保留与丢弃数组、等待和通知线程,最后创建并关闭 HardwareBuffer。每一步都问清楚:谁持有什么,怎样交到下一层,何时返回或清理。

把对象位置与空间的关系想成工作台上的分格盘:拿走积木后,格子可以继续用,盘子和工作台仍可能留着。这个比喻只解释“对象位置可复用”与“空间是否归还”的差别;格子不代表固定大小的物理页,真正的分配、回收和记账要回到源码。

场景-对象少了空间仍在

文章目录

9.1 整体架构 ART 管对象 Kernel 管页

先区分应用代码 运行时与操作系统

Java 源文件先被编译为字节码,再由 Android 构建工具转换为 DEX。设备上的 ART 负责装载相关类型、执行方法、管理 Java 对象和线程。ART 本身有大量 C++ 实现,与应用一起运行在用户空间;它没有因为“虚拟机”这个名字就变成另一个独立进程或 Kernel 模块。

一个普通应用进程内既有 Java 堆,也有 ART 元数据、JIT 代码缓存、线程栈、Native 分配、映射的 DEX/共享库等区域。Kernel 看到的是进程地址空间、页表、物理页、任务和调度状态;它不认识某一页里第几个字节是一个 ArrayList 元素。官方 ART 概览

下图是职责和接口关系图。箭头表示调用、使用或策略输入,标注了具体关系;它不是一次 new 必经的串行流程。

9.1-职责架构

先沿应用内部读,再看右侧的系统策略和设备分支。GC 回收 Java 对象、Kernel 回收页、lmkd 结束进程,是三个不同的动作。

常规对象分配、GC 和线程等待没有专属 HAL 或物理 Driver;设备缓冲区是独立分支,不能把它插入每次 Java 分配。

这些概念怎样配合

概念解决的问题在示例中怎样理解
DEX保存 Android 可执行字节码、类型与方法信息APK 内的 classes.dex 包含 LazyPayload
ClassLoader按一定委派与查找规则获得类型getClassLoader 返回应用加载器,按名字寻找类
ART Heap按运行时对象布局与分配器管理 Java 堆byte[]、持有这些引用的外层数组,以及 WeakReference 包装,都是 Java 对象
GC RootGC 可达性分析的起点活动线程中的引用、静态字段、有效 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
为什么等待 GCgc/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 时的控制路径;已加载、父加载器、共享库命中可以提前返回。

9.4-类查找与初始化

图中合并展示了不同入口的概念路线: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++ 分派器。

9.5-执行入口与编译

实线是执行路径,虚线是代码产生与安装关系,不表示应用每次调用都同步等待 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都依次经过的步骤;图中只示意一个对象/页关系,不表示实际数量或大小比例。

9.6-分配与缺页

图中缺页段是条件路径:页已有效驻留时直接访问,不发生这次异常。缺页也可能发生在分配器初始化对象头、清零数组等操作期间;图只展示分配返回后的后续访问这一时机,没有把缺页固定在 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 还指向对象,它仍可能存活。

9.7-可达与回收

实线持有关系与“删除引用”操作在边上分别标明;虚线表示弱关联。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的固定位置:条件改变、通知、可运行、调度与重新取锁逐步出现。这里示意一条正常唤醒路径,重排队及取消等分支继续看后文;播放顺序与停留时间不构成调度保证或实测时延。

9.8-通知与重获锁

这里表示一种先进入等待、后通知的情形;若条件已满足,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 初始化结果。

9.9-压力与维护分支

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先结束本持有者责任,只有其他持有和同步条件也满足时才可能最终释放。图中的额外持有者是条件示意,不是本例已经共享缓冲区的实测。

9.10-缓冲区责任

两条后端边是备选实现,不能串成“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 回顾 自测 源码速查与验证边界

回到开头那几个没有一起下降的数字,先沿着数组追问:它是否仍被强保活?本轮收集覆盖它了吗?对象位置能否复用,页又是否归还?最后,再确认自己读的是哪一种统计。分析线程等待与外部缓冲区时,也用同样的方法,分清通知、执行、结束本持有者责任与最终释放。

场景-带着分清的问题回看

用五条链重建本章

  1. 类型与执行:类名、加载器和 DEX 形成类型关联;初始化执行 clinit;方法入口按解释、编译、桥接或 JNI 路径继续,并返回结果或异常。
  2. 对象与页:ART 分配器先利用现有空间;需要时建立映射,访问某页时才可能触发缺页;GC 回收对象空间与 Kernel 页回收有不同粒度和时机。
  3. 线程与等待:Java Thread 关联 ART Thread,经 pthread/clone 启动;wait 释放 Monitor 后可能在 futex 等待,通知、重新调度与重新取锁分别发生。
  4. 系统压力:Framework 提供进程重要性,lmkd 结合压力和策略选择动作;mmd 维护 ZRAM 的配置与任务;结束进程后的资源归还仍受引用与退出路径约束。
  5. 设备缓冲区:Java 包装经 JNI 关联 Native GraphicBuffer,再按真实 Allocator/Mapper 走 Goldfish 或其他设备后端;fd、导入、设备工作与最终释放要分别追踪。

自测 先回答再核对

  1. 一个应用进程的所有内存都属于 ART Heap 吗?
  2. initialize=false 的 Class.forName 与 new 对象,有哪些不同?
  3. 两个 ClassLoader 返回同名类,为什么仍可能无法强转?
  4. 为什么不能用 ArtMethod::Invoke 代表所有 Java 方法调用?
  5. new byte 数组一定执行 mmap 吗?一个数组一定对应一页吗?
  6. TLAB 指针增加和 RSS 增加是什么关系?
  7. GC 后弱引用清除了,为什么 PSS 仍可能不下降?
  8. GC 总时间和应用暂停时间为什么不同?
  9. new Thread、start、run 与 Kernel clone 怎样区分?
  10. notifyAll 后等待线程为什么还可能没有运行?
  11. Java OOME、lmkd 回收、Kernel OOM 怎样收集证据区分?
  12. mmd 是否必须在 lmkd 之前执行一次维护?
  13. HardwareBuffer.close 为什么不能保证所有设备内存立即归还?
  14. 仅用 adb 注入、force-stop 或短命数组,能否证明所有 Kernel/Driver 链路已验证?

参考答案:

  1. 还包括 Native 分配、映射文件、代码缓存、栈、运行时元数据与可能的外部缓冲区。见 9.1。
  2. 前者请求找到 Class 而不要求初始化;创建实例要满足初始化与实例分配/构造条件。成功初始化可缓存。见 9.4。
  3. 类型身份包含定义加载器;同名不保证同一类型。见 9.4。
  4. 它是可定位的 runtime 调用入口之一;直接编译调用、内联、解释器等有其他入口。见 9.5。
  5. 先尝试现有堆空间;对象大小、页粒度、对齐、COW/大页等没有一一对应关系。见 9.6。
  6. 已有有效页中的分配可以只推进用户空间指针;新页访问才可能改变驻留情况。见 9.6。
  7. 弱引用只观察该对象的强可达性;space 可保留复用,进程还有其他映射/共享页及计费变化。见 9.7。
  8. 并发阶段与暂停交替,还要区分分配等待、调度等待和 CPU 时间。见 9.7~9.8。
  9. 创建 Java 对象不等于新建线程;start 才沿 Native 创建路径,直接 run 在调用线程执行。见 9.8。
  10. 通知线程可能仍持锁,等待线程还要获调度、重新取锁并检查条件。见 9.8。
  11. 分别保留 ART 异常分配上下文、lmkd 选择/终止日志、Kernel OOM/退出证据;时间与 PID 属于同轮。见 9.9~9.11。
  12. 两者职责与策略并列,取决于能力和配置,没有统一的必然串行关系。见 9.9。
  13. 它只释放本包装所持资源;其他 fd、导入者和在途设备工作仍可能持有。见 9.10。
  14. 不能。它们只覆盖对应入口/动作;完整路径需要真实后端与该次运行证据。见 9.11。

按问题查关键符号

要追什么文件或符号
委派与自己的 DEXClassLoader.loadClass、BaseDexClassLoader.findClass、DexPathList.findClass
Native 定义与初始化DexFile_defineClassNative、ClassLinker::DefineClass / InitializeClass
方法执行与 JITArtMethod::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 与虚拟设备模块使用公开固定提交文件,不把临时下载目录当成设备当前源码构建树。

项目固定提交
artb753cf97923c3695338d21466fa14c57b480a59a
libcore4ebfb391ee0109d16abe6e2bc965724b940928c5
bionic06356e41c5ed7b12220b24c05ba4fdb873b126a7
frameworks/base94b4c163b7dfe5ce3607f7bb8456f9573f7de57d
frameworks/nativeae266dcb706d083868578cfedce381ef44488a07
system/memory/lmkdc3601e823bd07c9c190f67e2f9bc7486e4978328
system/memory/mmdcf66bc31a4002e6f786da7c5a45e4088d19530ed
device/generic/goldfish296e55aa0244e8929e393e00e34471fef2a5d662
external/mesa3d875160ed32cc5bc32777fa04870a0a57ed38c987
kernel/commonccafb60de224d35a8bc14de33e1cd47caaaa786b
kernel/common-modules/virtual-device544e91ec0222069e5477857d16614b453e137340

概念与契约延伸阅读: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;

参考资料

概念与工具

固定版本源码