使用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能够构建出强大的性能分析，故障排除以及动态代码注入工具。