使用JVMTI（JVM Tool Interface）实现自定义的Java运行时监控与诊断工具 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，开始吧。

使用 JVMTI 实现自定义的 Java 运行时监控与诊断工具

各位好，今天我们来深入探讨如何利用 JVMTI（JVM Tool Interface）构建自定义的 Java 运行时监控与诊断工具。JVMTI 是 JVM 提供的原生接口，允许我们以原生代码（通常是 C/C++）编写代理程序，深入 JVM 内部，获取各种运行时信息，并对 JVM 的行为进行干预。这赋予了我们极大的灵活性，可以实现远超 Java 代码本身能力的监控和诊断功能。

1. JVMTI 简介及优势

JVMTI 提供了丰富的接口，可以访问 JVM 的各种状态，包括：

类加载信息： 了解类的加载、卸载过程，以及类的定义和结构。
线程信息： 监控线程的创建、启动、停止、阻塞等状态，以及线程的堆栈信息。
堆内存信息： 获取堆内存的使用情况，包括对象数量、大小、以及垃圾回收的详细信息。
方法执行信息： 跟踪方法的调用过程，包括方法的进入、退出、以及异常抛出。
事件通知： 注册感兴趣的事件，例如类加载、线程启动、异常抛出等，并在事件发生时收到通知。

相比于 Java 自身的监控工具（如 JMX），JVMTI 的优势在于：

更底层： JVMTI 直接与 JVM 交互，可以访问更底层的信息，不受 Java 安全模型的限制。
更高性能： JVMTI 使用原生代码编写，性能更高，对目标 JVM 的影响更小。
更灵活： JVMTI 提供了更多的控制权，可以实现更复杂的监控和诊断功能。

2. 开发环境搭建

在使用 JVMTI 之前，我们需要搭建一个合适的开发环境。这通常包括：

JDK： 需要安装 JDK，并确保 JAVA_HOME 环境变量已正确配置。
C/C++ 编译器： 需要安装 C/C++ 编译器，例如 GCC 或 Visual Studio。
JVMTI 头文件和库文件： JDK 中包含了 JVMTI 的头文件和库文件，通常位于 $JAVA_HOME/include 和 $JAVA_HOME/lib 目录下。
IDE： 可以使用任何支持 C/C++ 开发的 IDE，例如 Eclipse CDT 或 Visual Studio。

3. JVMTI 代理程序的基本结构

一个 JVMTI 代理程序通常包含以下几个部分：

代理程序的入口函数： 这是 JVM 加载代理程序时调用的函数，通常命名为 Agent_OnLoad 或 Agent_OnAttach。
JVMTI 环境： 通过 JavaVM 指针获取 JVMTI 环境，用于调用 JVMTI 提供的接口。
事件注册： 注册感兴趣的事件，并指定相应的回调函数。
回调函数： 当注册的事件发生时，JVM 会调用相应的回调函数，我们可以在回调函数中处理事件。
代理程序的卸载函数： 这是 JVM 卸载代理程序时调用的函数，通常命名为 Agent_OnUnload。

4. 编写 JVMTI 代理程序：类加载监控

让我们通过一个简单的例子来演示如何编写 JVMTI 代理程序。我们将编写一个代理程序，用于监控类的加载过程，并在类加载时打印类名。

首先，创建一个名为 ClassLoadMonitor.c 的 C 文件，包含以下代码：

#include <jvmti.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static jvmtiEnv *jvmti;

// 类加载事件回调函数
static void JNICALL ClassFileLoadHook(jvmtiEnv *jvmti_env,
                                     JNIEnv* jni_env,
                                     jclass class,
                                     jobject class_loader,
                                     const char* class_name,
                                     jobject protection_domain,
                                     jint class_data_len,
                                     const unsigned char* class_data,
                                     jint* new_class_data_len,
                                     unsigned char** new_class_data) {
  printf("Class loaded: %sn", class_name);
}

// 代理程序加载时调用的函数
JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM *vm, char *options, void *reserved) {
  jvmtiError error;
  jint result = (*vm)->GetEnv(vm, (void **)&jvmti, JVMTI_VERSION_1_2);
  if (result != JNI_OK) {
    fprintf(stderr, "ERROR: Unable to access JVMTI!n");
    return JNI_ERR;
  }

  // 设置 JVMTI 功能
  jvmtiCapabilities capabilities;
  memset(&capabilities, 0, sizeof(jvmtiCapabilities));
  capabilities.can_generate_all_class_hook_events = 1;
  error = (*jvmti)->AddCapabilities(jvmti, &capabilities);
  if (error != JVMTI_ERROR_NONE) {
    fprintf(stderr, "ERROR: Unable to get necessary JVMTI capabilities.n");
    return JNI_ERR;
  }

  // 设置事件回调
  jvmtiEventCallbacks callbacks;
  memset(&callbacks, 0, sizeof(jvmtiEventCallbacks));
  callbacks.ClassFileLoadHook = &ClassFileLoadHook;
  error = (*jvmti)->SetEventCallbacks(jvmti, &callbacks, sizeof(jvmtiEventCallbacks));
  if (error != JVMTI_ERROR_NONE) {
    fprintf(stderr, "ERROR: Unable to set event callbacks.n");
    return JNI_ERR;
  }

  // 开启事件通知
  error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_CLASS_FILE_LOAD_HOOK, NULL);
  if (error != JVMTI_ERROR_NONE) {
    fprintf(stderr, "ERROR: Unable to enable event notification.n");
    return JNI_ERR;
  }

  printf("JVMTI agent loaded successfully.n");
  return JNI_OK;
}

// 代理程序卸载时调用的函数
JNIEXPORT void JNICALL Agent_OnUnload(JavaVM *vm) {
  printf("JVMTI agent unloaded.n");
}

接下来，编译该文件，生成动态链接库。在 Linux 下，可以使用以下命令：

gcc -shared -fPIC -I$JAVA_HOME/include -I$JAVA_HOME/include/linux ClassLoadMonitor.c -o libClassLoadMonitor.so

在 Windows 下，可以使用 Visual Studio 或 MinGW 编译生成 DLL 文件。

现在，我们可以运行一个 Java 程序，并加载该代理程序。例如，创建一个名为 Test.java 的 Java 文件，包含以下代码：

public class Test {
  public static void main(String[] args) {
    System.out.println("Hello, JVMTI!");
    new Test(); //触发类加载
  }
}

使用以下命令运行该程序，并加载代理程序：

java -agentpath:/path/to/libClassLoadMonitor.so Test

将 /path/to/libClassLoadMonitor.so 替换为实际的动态链接库路径。

运行结果将包含以下输出：

JVMTI agent loaded successfully.
Hello, JVMTI!
Class loaded: Test

这表明代理程序已成功加载，并成功监控到 Test 类的加载。

5. JVMTI 事件类型及处理

JVMTI 提供了多种事件类型，可以监控 JVM 的各种行为。以下是一些常用的事件类型：

事件类型	描述
`JVMTI_EVENT_VM_INIT`	JVM 初始化完成时触发。
`JVMTI_EVENT_VM_START`	JVM 开始运行 Java 代码时触发。
`JVMTI_EVENT_VM_DEATH`	JVM 关闭时触发。
`JVMTI_EVENT_THREAD_START`	线程启动时触发。
`JVMTI_EVENT_THREAD_END`	线程结束时触发。
`JVMTI_EVENT_CLASS_LOAD`	类加载时触发。
`JVMTI_EVENT_CLASS_UNLOAD`	类卸载时触发。
`JVMTI_EVENT_METHOD_ENTRY`	方法进入时触发。
`JVMTI_EVENT_METHOD_EXIT`	方法退出时触发。
`JVMTI_EVENT_EXCEPTION`	异常抛出时触发。
`JVMTI_EVENT_GARBAGE_COLLECTION_START`	垃圾回收开始时触发。
`JVMTI_EVENT_GARBAGE_COLLECTION_FINISH`	垃圾回收结束时触发。
`JVMTI_EVENT_OBJECT_ALLOC`	对象分配时触发。
`JVMTI_EVENT_CLASS_FILE_LOAD_HOOK`	在类文件加载之前，允许修改类文件数据。

要处理这些事件，需要在代理程序中注册相应的回调函数，并在回调函数中处理事件。例如，要监控线程的启动和结束，可以注册 JVMTI_EVENT_THREAD_START 和 JVMTI_EVENT_THREAD_END 事件的回调函数。

6. 编写 JVMTI 代理程序：方法耗时监控

现在，让我们编写一个更复杂的代理程序，用于监控方法的耗时。我们将使用 JVMTI_EVENT_METHOD_ENTRY 和 JVMTI_EVENT_METHOD_EXIT 事件来记录方法的进入和退出时间，并计算方法的耗时。

首先，创建一个名为 MethodTimeMonitor.c 的 C 文件，包含以下代码：

#include <jvmti.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

static jvmtiEnv *jvmti;
static jrawMonitorID lock;

typedef struct {
  jmethodID method;
  clock_t start_time;
} MethodInfo;

//方法进入事件回调函数
static void JNICALL MethodEntry(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method) {
    jvmtiError error;
    char *method_name = NULL;
    char *class_name = NULL;

    // 获取方法名和类名
    error = (*jvmti)->GetMethodName(jvmti, method, &method_name, NULL, NULL);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "Error getting method name: %dn", error);
        return;
    }

    jclass declaring_class;
    error = (*jvmti)->GetMethodDeclaringClass(jvmti, method, &declaring_class);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "Error getting declaring class: %dn", error);
        (*jvmti)->Deallocate(jvmti, (unsigned char *)method_name);
        return;
    }

    error = (*jvmti)->GetClassSignature(jvmti, declaring_class, &class_name, NULL);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "Error getting class signature: %dn", error);
        (*jvmti)->Deallocate(jvmti, (unsigned char *)method_name);
        return;
    }
    //删除类名中的L和;
    char *simple_class_name = strdup(class_name + 1);
    simple_class_name[strlen(simple_class_name) - 1] = '';
    // 将/替换成.
    for (int i = 0; simple_class_name[i] != ''; i++) {
        if (simple_class_name[i] == '/') {
            simple_class_name[i] = '.';
        }
    }
    //获取锁
    error = (*jvmti)->RawMonitorEnter(jvmti, lock);
    if (error != JVMTI_ERROR_NONE) {
            fprintf(stderr, "Error entering raw monitor: %dn", error);
    }

    MethodInfo *method_info = (MethodInfo *)malloc(sizeof(MethodInfo));
    if (method_info == NULL) {
        fprintf(stderr, "Error allocating memory for method info.n");
        return;
    }

    method_info->method = method;
    method_info->start_time = clock();

    // 将方法信息添加到关联数据中
    error = (*jvmti)->SetLocalObject(jvmti, thread, 1, method_info);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "Error setting local object: %dn", error);
        free(method_info);
    }

    //释放锁
    error = (*jvmti)->RawMonitorExit(jvmti, lock);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "Error exiting raw monitor: %dn", error);
    }

    printf("Method Entry: %s.%sn", simple_class_name, method_name);

    (*jvmti)->Deallocate(jvmti, (unsigned char *)method_name);
    (*jvmti)->Deallocate(jvmti, (unsigned char *)class_name);
    free(simple_class_name);
}

//方法退出事件回调函数
static void JNICALL MethodExit(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method, jboolean was_popped_by_exception, jvalue return_value) {
    jvmtiError error;
    clock_t end_time = clock();
    double cpu_time_used;
    char *method_name = NULL;
    char *class_name = NULL;

    // 获取方法名和类名
    error = (*jvmti)->GetMethodName(jvmti, method, &method_name, NULL, NULL);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "Error getting method name: %dn", error);
        return;
    }

    jclass declaring_class;
    error = (*jvmti)->GetMethodDeclaringClass(jvmti, method, &declaring_class);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "Error getting declaring class: %dn", error);
        (*jvmti)->Deallocate(jvmti, (unsigned char *)method_name);
        return;
    }

    error = (*jvmti)->GetClassSignature(jvmti, declaring_class, &class_name, NULL);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "Error getting class signature: %dn", error);
        (*jvmti)->Deallocate(jvmti, (unsigned char *)method_name);
        return;
    }
     //删除类名中的L和;
    char *simple_class_name = strdup(class_name + 1);
    simple_class_name[strlen(simple_class_name) - 1] = '';
    // 将/替换成.
    for (int i = 0; simple_class_name[i] != ''; i++) {
        if (simple_class_name[i] == '/') {
            simple_class_name[i] = '.';
        }
    }
    //获取锁
    error = (*jvmti)->RawMonitorEnter(jvmti, lock);
    if (error != JVMTI_ERROR_NONE) {
            fprintf(stderr, "Error entering raw monitor: %dn", error);
    }

    MethodInfo *method_info = NULL;
    error = (*jvmti)->GetLocalObject(jvmti, thread, 1, (jobject*)&method_info);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "Error getting local object: %dn", error);
    }

    if (method_info != NULL && method_info->method == method) {
        cpu_time_used = ((double) (end_time - method_info->start_time)) / CLOCKS_PER_SEC;
        printf("Method Exit: %s.%s, Time: %f secondsn", simple_class_name, method_name, cpu_time_used);
        free(method_info);
        (*jvmti)->SetLocalObject(jvmti, thread, 1, NULL); // 清除关联数据
    }

    //释放锁
    error = (*jvmti)->RawMonitorExit(jvmti, lock);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "Error exiting raw monitor: %dn", error);
    }
    (*jvmti)->Deallocate(jvmti, (unsigned char *)method_name);
    (*jvmti)->Deallocate(jvmti, (unsigned char *)class_name);
    free(simple_class_name);
}

// 代理程序加载时调用的函数
JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM *vm, char *options, void *reserved) {
  jvmtiError error;
  jint result = (*vm)->GetEnv(vm, (void **)&jvmti, JVMTI_VERSION_1_2);
  if (result != JNI_OK) {
    fprintf(stderr, "ERROR: Unable to access JVMTI!n");
    return JNI_ERR;
  }

  // 创建锁
    error = (*jvmti)->CreateRawMonitor(jvmti, "method_time_monitor", &lock);
    if (error != JVMTI_ERROR_NONE) {
        fprintf(stderr, "ERROR: Unable to create raw monitor!n");
        return JNI_ERR;
    }

  // 设置 JVMTI 功能
  jvmtiCapabilities capabilities;
  memset(&capabilities, 0, sizeof(jvmtiCapabilities));
  capabilities.can_generate_method_entry_events = 1;
  capabilities.can_generate_method_exit_events = 1;
  capabilities.can_access_local_variables = 1;
  capabilities.can_get_source_file_name = 1; // 获取源码文件名
  capabilities.can_get_line_numbers = 1; // 获取行号
  error = (*jvmti)->AddCapabilities(jvmti, &capabilities);
  if (error != JVMTI_ERROR_NONE) {
    fprintf(stderr, "ERROR: Unable to get necessary JVMTI capabilities.n");
    return JNI_ERR;
  }

  // 设置事件回调
  jvmtiEventCallbacks callbacks;
  memset(&callbacks, 0, sizeof(jvmtiEventCallbacks));
  callbacks.MethodEntry = &MethodEntry;
  callbacks.MethodExit = &MethodExit;
  error = (*jvmti)->SetEventCallbacks(jvmti, &callbacks, sizeof(jvmtiEventCallbacks));
  if (error != JVMTI_ERROR_NONE) {
    fprintf(stderr, "ERROR: Unable to set event callbacks.n");
    return JNI_ERR;
  }

  // 开启事件通知
  error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_METHOD_ENTRY, NULL);
  if (error != JVMTI_ERROR_NONE) {
    fprintf(stderr, "ERROR: Unable to enable event notification.n");
    return JNI_ERR;
  }

  error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_METHOD_EXIT, NULL);
  if (error != JVMTI_ERROR_NONE) {
    fprintf(stderr, "ERROR: Unable to enable event notification.n");
    return JNI_ERR;
  }

  printf("JVMTI agent loaded successfully.n");
  return JNI_OK;
}

// 代理程序卸载时调用的函数
JNIEXPORT void JNICALL Agent_OnUnload(JavaVM *vm) {
  printf("JVMTI agent unloaded.n");
}

编译该文件，生成动态链接库。在 Linux 下，可以使用以下命令：

gcc -shared -fPIC -I$JAVA_HOME/include -I$JAVA_HOME/include/linux MethodTimeMonitor.c -o libMethodTimeMonitor.so

在 Windows 下，可以使用 Visual Studio 或 MinGW 编译生成 DLL 文件。

现在，我们可以运行一个 Java 程序，并加载该代理程序。例如，创建一个名为 Test.java 的 Java 文件，包含以下代码：

public class Test {
  public static void main(String[] args) throws InterruptedException {
    System.out.println("Hello, JVMTI!");
    long startTime = System.currentTimeMillis();
    doSomething();
    long endTime = System.currentTimeMillis();
    System.out.println("Main method Time: " + (endTime - startTime) + "ms");
  }

  public static void doSomething() throws InterruptedException {
    Thread.sleep(1000);
    System.out.println("Doing something...");
  }
}

使用以下命令运行该程序，并加载代理程序：

java -agentpath:/path/to/libMethodTimeMonitor.so Test

将 /path/to/libMethodTimeMonitor.so 替换为实际的动态链接库路径。

运行结果将包含以下输出：

JVMTI agent loaded successfully.
Method Entry: Test.main
Hello, JVMTI!
Method Entry: Test.doSomething
Doing something...
Method Exit: Test.doSomething, Time: 1.000000 seconds
Main method Time: 1001ms
Method Exit: Test.main, Time: 1.001000 seconds

这表明代理程序已成功加载，并成功监控到 doSomething 和 main 方法的耗时。

7. 异常处理和资源管理

在编写 JVMTI 代理程序时，需要特别注意异常处理和资源管理。由于 JVMTI 使用原生代码编写，因此很容易出现内存泄漏、空指针异常等问题。

内存管理： 使用 (*jvmti)->Allocate 和 (*jvmti)->Deallocate 函数来分配和释放内存，避免使用 malloc 和 free 函数，因为 JVM 的垃圾回收器可能无法跟踪这些内存。
异常处理： 使用 try...catch 语句来捕获异常，并进行适当的处理，避免 JVM 崩溃。
锁：在多线程环境下，需要使用锁来保护共享资源，避免数据竞争。

8. 高级应用：动态代码注入

JVMTI 不仅可以用于监控和诊断，还可以用于动态代码注入。通过 JVMTI_EVENT_CLASS_FILE_LOAD_HOOK 事件，可以在类加载之前修改类文件数据，从而实现动态代码注入。

这可以用于实现 AOP（面向切面编程）、热修复等功能。但需要注意的是，动态代码注入可能会破坏 JVM 的安全性，因此需要谨慎使用。

9. 注意事项

版本兼容性： JVMTI 的接口可能会在不同的 JDK 版本中发生变化，因此需要注意版本兼容性。
性能影响： JVMTI 代理程序可能会对目标 JVM 的性能产生影响，因此需要进行性能测试，并进行优化。
安全性： JVMTI 代理程序可以访问 JVM 的底层信息，因此需要注意安全性，避免恶意代码注入。

10. 总结:JVMTI工具的强大之处

JVMTI 提供了强大的功能，可以用于构建自定义的 Java 运行时监控和诊断工具。使用 JVMTI 可以访问 JVM 的底层信息，实现远超 Java 代码本身能力的功能。但是，使用 JVMTI 也需要注意版本兼容性、性能影响和安全性问题。

掌握JVMTI能够深入了解JVM内部机制。通过JVMTI能够构建出强大的性能分析，故障排除以及动态代码注入工具。

发表回复 取消回复

发表回复取消回复