Async-profiler 内存采样机制解析：从原理到实现

引言

在 Java 性能调优的工具箱中，async-profiler 是一款备受青睐的低开销采样分析器。它不仅能分析 CPU 热点，还能精确追踪内存分配情况。本文将深入探讨 async-profiler 实现内存采样的多种机制，结合代码示例解析其工作原理。

为什么需要内存采样？

在排查 Java 应用的内存问题时，我们常常需要回答这些问题：

哪些对象占用了最多的堆内存？
哪些代码路径产生了大量临时对象？
垃圾回收频繁的根源是什么？

async-profiler 的内存采样功能能够追踪对象分配的位置和大小，帮助我们定位内存泄漏和过度分配问题。

JVM 内存分配基础

在深入 async-profiler 的实现之前，先简要了解 JVM 的内存分配机制：

TLAB（Thread Local Allocation Buffer）：每个线程独享的小型内存区域，用于快速分配小型对象
大对象直接分配：超过 TLAB 大小的对象会直接在堆上分配
栈上分配：某些情况下，对象可以直接在栈上分配，避免堆内存压力

Async-profiler 内存采样的多种机制

机制一：JVMTI ObjectSample 事件（JDK 11+）

JVMTI（Java Virtual Machine Tool Interface）提供了 ObjectSample 事件，允许在对象分配时触发回调。这是最直接的内存采样方式，但在 JDK 11 之前存在局限性。

java 复制代码

// JVMTI ObjectSample 事件监听示例
public class AllocationListener {
    public static void main(String[] args) throws Exception {
        // 通过JVMTI注册对象分配事件
        Agent.setObjectAllocationCallback((thread, classDesc, size) -> {
            System.out.printf("分配对象: %s, 大小: %d 字节\n", classDesc, size);
        });
        
        // 应用代码继续执行
        // ...
    }
}

局限性：

在 JDK 11 之前，只能捕获大对象（超过 TLAB 大小）的分配
启用该事件会带来显著的性能开销

机制二：二进制插桩（JDK 11 之前的主要方式）

对于 JDK 11 之前的版本，async-profiler 采用更底层的二进制插桩技术，直接修改 HotSpot VM 的代码。

关键步骤：

1. 定位目标函数：在 HotSpot VM 的二进制代码中找到关键的内存分配函数

cpp 复制代码

 if ((ne = libjvm->findSymbolByPrefix("_ZN11AllocTracer27send_allocation_in_new_tlab")) != NULL &&
        (oe = libjvm->findSymbolByPrefix("_ZN11AllocTracer28send_allocation_outside_tlab")) != NULL) {
        _trap_kind = 1;  // JDK 10+
    } else if ((ne = libjvm->findSymbolByPrefix("_ZN11AllocTracer33send_allocation_in_new_tlab_eventE11KlassHandleP8HeapWord")) != NULL &&
               (oe = libjvm->findSymbolByPrefix("_ZN11AllocTracer34send_allocation_outside_tlab_eventE11KlassHandleP8HeapWord")) != NULL) {
        _trap_kind = 1;  // JDK 8u262+
    } else if ((ne = libjvm->findSymbolByPrefix("_ZN11AllocTracer33send_allocation_in_new_tlab_event")) != NULL &&
               (oe = libjvm->findSymbolByPrefix("_ZN11AllocTracer34send_allocation_outside_tlab_event")) != NULL) {
        _trap_kind = 2;  // JDK 7-9
    } else {
        return Error("No AllocTracer symbols found. Are JDK debug symbols installed?");
    }

这个步骤需要JDK的Debug Symbols，所以很多系统比如Alpine运行的java应用就不支持内存采样，因为Alpine的SDK为了精简体积默认都不包含Debug Symbols。

2. 插入陷阱指令：在函数入口处写入跳转指令，指向自定义的处理函数

cpp 复制代码

# 伪代码：在目标函数起始位置写入跳转指令
push <trap_handler_address>
ret

3. 陷阱处理函数：收集分配信息并采样堆栈

cpp 复制代码

// 陷阱处理函数
void trap_handler(KlassHandle klass, HeapWord* obj) {
    // 获取对象大小
    size_t size = get_object_size(klass);
    
    // 采样当前线程的堆栈
    void* stack[100];
    int depth = capture_stacktrace(stack, 100);
    
    // 记录分配事件
    record_allocation(obj, size, stack, depth);
    
    // 跳回原始函数继续执行
    execute_original_instructions();
}

4. 恢复原始代码：采样结束后恢复原始指令，减少对性能的影响

这种方法虽然强大，但也有明显缺点：

与特定 JDK 版本深度耦合，兼容性差
需要JDK包含Debug Symbols，很多系统比如Alpine的SDK都支持
需要 root 权限才能修改运行中的 VM 进程
实现复杂，稍有不慎就可能导致 JVM 崩溃

机制三：LD_PRELOAD 技术（针对堆外内存）

对于 Java 堆外内存分配（如 JNI 调用），async-profiler 使用 LD_PRELOAD 技术拦截 C 库的内存分配函数。

cpp 复制代码

// preload.c - 使用LD_PRELOAD拦截malloc
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>

// 原始malloc函数指针
static void* (*real_malloc)(size_t) = NULL;

// 自定义malloc函数
void* malloc(size_t size) {
    // 首次调用时获取原始malloc函数地址
    if (!real_malloc) {
        real_malloc = dlsym(RTLD_NEXT, "malloc");
    }
    
    // 记录分配前的时间和堆栈
    void* ptr = real_malloc(size);
    
    // 记录分配信息
    record_allocation(ptr, size, get_current_stack());
    
    return ptr;
}

使用方式：

复制代码

# 编译共享库
gcc -shared -fPIC preload.c -o preload.so -ldl

# 运行Java程序时加载拦截库
LD_PRELOAD=./preload.so java YourMainClass

机制四：DTrace/SystemTap（特定平台）

在支持 DTrace 或 SystemTap 的系统中，async-profiler 可以使用这些工具进行动态插桩。

DTrace 示例：

cpp 复制代码

// 监控Java对象分配的DTrace脚本
hotspot$target:::object-allocated
{
    // 获取对象类型和大小
    @allocations[copyinstr(arg1)] = sum(arg2);
    
    // 记录堆栈
    trace(arg0);
    ustack();
}

运行方式：

复制代码

dtrace -s alloc.d -p <java_pid>

这种方法的优势是无需修改 Java 程序或 VM，但依赖特定平台支持。

Async-profiler 内存采样实战

下面通过一个简单的 Java 程序，演示如何使用 async-profiler 进行内存采样。

示例程序：

java 复制代码

import java.util.ArrayList;
import java.util.List;

public class MemoryAllocationDemo {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        
        // 生成大量字符串对象
        for (int i = 0; i < 1000000; i++) {
            list.add("Object-" + i);
            
            // 每10万次分配休眠一下，方便我们进行采样
            if (i % 100000 == 0) {
                Thread.sleep(100);
            }
        }
        
        System.out.println("分配完成，按任意键退出...");
        System.in.read();
    }
}

使用 async-profiler 进行内存采样：

bash 复制代码

# 编译Java程序
javac MemoryAllocationDemo.java

# 运行程序
java MemoryAllocationDemo &

# 获取Java进程ID
PID=$!

# 使用async-profiler进行10秒的内存分配采样
./profiler.sh -e alloc -d 10 $PID

# 生成火焰图
./profiler.sh -e alloc -f allocation-flamegraph.svg $PID

总结

async-profiler 的内存采样机制根据不同 JDK 版本和场景采用了多种技术：

JVMTI ObjectSample：简单直接，但在 JDK 11 之前功能有限
二进制插桩：强大但复杂，与特定 JDK 版本深度绑定，且需要SDK含有Debug Symbols
LD_PRELOAD：适用于堆外内存分配的拦截
DTrace/SystemTap：平台特定但无需修改目标程序

理解这些机制有助于我们在不同场景下选择最合适的工具和方法，更高效地解决 Java 应用的内存问题。