Java程序执行的基本过程

前言

本文旨在记录近期研读Java源码的学习心得与疑难问题。由于个人理解水平有限，文中内容可能存在疏漏，恳请读者不吝指正。

Java程序执行的基本过程

《揭秘Java程序启动的底层奥秘》一文中详细介绍了Java程序的执行流程：

  1. 程序启动时，jdk/src/share/bin/main.c会调用java.c中的JLI_Launch()方法

  2. JLI_Launch()方法主要完成以下工作：

    • 调用CreateExecutionEnvironment()方法初始化执行环境并收集环境参数
    • 通过LoadJavaVM()加载libjvm.so动态库，查找并获取创建JVM的方法
    • 在JVMInit()中完成JVM的初始化工作，并最终调用Java类中的main方法

JavaVM初始化的过程

在 OpenJDK 8u44 源码中，位于 jdk/src/solaris/bin/java_md_solinux.c 文件的 LoadJavaVM 方法如下：

jboolean LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)
{
    void *libjvm;
    // 省略异常检查代码

    libjvm = dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL);
    // 省略有关打开libjvm.so失败的检测代码

    ifn->CreateJavaVM = (CreateJavaVM_t)dlsym(libjvm, "JNI_CreateJavaVM");
    // 省略异常检查代码

    ifn->GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t)
        dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs");
    // 省略异常检查代码

    ifn->GetCreatedJavaVMs = (GetCreatedJavaVMs_t)
        dlsym(libjvm, "JNI_GetCreatedJavaVMs");
    // 省略异常检查代码

    return JNI_TRUE;
}

方法dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL);中第二个参数RTLD_NOW、RTLD_GLOBALRTLD_GLOBAL作用如下：

  • 这两个的参数决定了libjvm.so被加载到内存时的行为。JDK 这样设置是非常关键的：

    • RTLD_NOW (立即解析)：含义：告诉动态链接器在 dlopen 返回之前，必须解析出 libjvm.so 中所有未定义的符号（函数和变量）。

    • JDK 中的作用：如果在加载 JVM 核心库时有任何缺失的依赖，程序会立即报错（抛出类似 UnsatisfiedLinkError 或启动失败），而不是等到运行时执行到某行代码才崩溃。这保证了 JVM 启动的稳定性。

  • RTLD_GLOBAL (全局可见)：

    • 含义：告诉动态链接器，将libjvm.so导出的全局符号（例如 JNI_CreateJavaVM 等）放到全局符号表中。

    • JDK 中的作用：这是必不可少的。因为 Java 启动器（java 命令）加载了 libjvm.so 后，后续 Java 程序中可能会用到 JNI 并通过 System.loadLibrary 加载用户自定义的 .so 文件。使用 RTLD_GLOBAL 可以确保这些后加载的用户 C/C++ 库能够直接调用 JVM 暴露出来的 JNI 接口。

补充说明

  • RTLD_NOW，并不是在 JDK 的源代码中定义的，而是由操作系统（Linux/Solaris）的 C 标准库（libc）提供的 POSIX 标准宏。对于ubuntu系统dlfcn.h文件位于/usr/include/x86_64-linux-gnu/bits/目录下面

ubuntu系统dlfcn.h中有关RTLD_NOW和RTLD_GLOBAL RTLD_GLOBAL 定义

JVM 启动函数

dlopen()方法成功把 JVM 的核心库（libjvm.so）加载到操作系统的内存中，接下来的核心任务就是找到并调用启动 JVM 的入口函数。在上面LoadJavaVM()方法代码中可以看到在libjvm.so加载完成后，会将设置InvocationFunctions定义的CreateJavaVM()、GetDefaultJavaVMInitArgs()、GetCreatedJavaVMs()的函数指针。通过这三个函数完成JVM的创建和启动。

  1. InvocationFunctions 是什么？
    在 C/C++ 中，我们要调用一个动态链接库里（运行时才加载）的函数，不能直接写函数名调用，而是必须先拿到这个函数的内存地址（函数指针）。

InvocationFunctions 是定义在 JDK源码jdk\src\share\bin\java.h中的一个结构体，专门用来存放几个最核心的 JNI（Java Native Interface）函数指针。它的定义大致如下：


typedef jint (JNICALL *CreateJavaVM_t)(JavaVM **pvm, void **env, void *args);
typedef jint (JNICALL *GetDefaultJavaVMInitArgs_t)(void *args);
typedef jint (JNICALL *GetCreatedJavaVMs_t)(JavaVM **vmBuf, jsize bufLen, jsize *nVMs);

typedef struct {
    CreateJavaVM_t CreateJavaVM;
    GetDefaultJavaVMInitArgs_t GetDefaultJavaVMInitArgs;
    GetCreatedJavaVMs_t GetCreatedJavaVMs;
} InvocationFunctions;

你可以把它想象成一个“占位符表”。在 LoadJavaVM 被调用之前，这个表是空的；LoadJavaVM 的任务之一，就是把表填满。

  1. 使用 dlsym 映射函数地址
    在 LoadJavaVM 方法内部，当 dlopen 执行成功后，会返回一个动态库的句柄（handle，通常存放在一个叫 libjvm 的变量里）。

接着，JDK 会使用另一个 POSIX 标准 API —— dlsym。它的作用是根据“函数的名字（字符串）”，在刚才加载的 libjvm.so 中去寻找对应的内存地址，并强转为函数指针赋给 ifn：


// 1. 查找 JNI_CreateJavaVM 函数的真实内存地址
ifn->CreateJavaVM = (void *)dlsym(libjvm, "JNI_CreateJavaVM");

// 2. 查找 JNI_GetDefaultJavaVMInitArgs 的地址
ifn->GetDefaultJavaVMInitArgs = (void *)dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs");

// 3. 查找 JNI_GetCreatedJavaVMs 的地址
ifn->GetCreatedJavaVMs = (void *)dlsym(libjvm, "JNI_GetCreatedJavaVMs");

如果在 dlsym 过程中找不到这些核心函数，说明加载的 libjvm.so 文件损坏或者版本不对，程序会直接报错退出。

  1. 移交控制权：启动 JVM
    一旦 LoadJavaVM 执行完毕并返回成功，此时外层调用它的函数就拿到了一份填满函数地址的 InvocationFunctions *ifn 结构体。

回到 JDK 启动器的主流程中（通常是在 InitializeJVM 这个函数里），启动器会把我们在命令行输入的 -Xmx1G、-cp 等参数打包成 args，然后直接通过函数指针调用：


// 真正启动 JVM 的历史性时刻！
result = ifn->CreateJavaVM(&jvm, (void **)&env, &args);

当这行代码执行时，发生了什么？

  1. C 程序的控制权正式交给了 libjvm.so 内部的 C++ 代码。
  2. JVM 开始在底层初始化内存空间、垃圾回收器（GC）、线程池、类加载器等系统级组件。
  3. 初始化完成后，JVM 会通过传入的 env（JNI 环境指针）去加载你的主类（包含 public static void main 的类），并开始解释或编译执行你的 Java 字节码。

启动JVM过程涉及到的核心代码

jdk\src\share\bin\main.c中main()函数的核心逻辑，命令行执行java命令的入口，执行JLI_Launch()函数。


int
main(int argc, char **argv)
{
    int margc;
    char** margv;
    // 省略部分代码

    return JLI_Launch(margc, margv,
                   sizeof(const_jargs) / sizeof(char *), const_jargs,
                   sizeof(const_appclasspath) / sizeof(char *), const_appclasspath,
                   FULL_VERSION,
                   DOT_VERSION,
                   *margv,
                   *margv,
                   (const_jargs != NULL) ? JNI_TRUE : JNI_FALSE,
                   const_cpwildcard, const_javaw, const_ergo_class);
}

jdk\src\share\bin\java.c中JLI_Launch函数的核心逻辑执行LoadJavaVM()函数和JVMInit()函数。


int JLI_Launch(int argc, char ** argv,              /* main argc, argc */
        int jargc, const char** jargv,          /* java args */
        int appclassc, const char** appclassv,  /* app classpath */
        const char* fullversion,                /* full version defined */
        const char* dotversion,                 /* dot version defined */
        const char* pname,                      /* program name */
        const char* lname,                      /* launcher name */
        jboolean javaargs,                      /* JAVA_ARGS */
        jboolean cpwildcard,                    /* classpath wildcard*/
        jboolean javaw,                         /* windows-only javaw */
        jint ergo                               /* ergonomics class policy */
)
{
    // 省略部分代码，只保留核心代码
    InvocationFunctions ifn;
    ifn.CreateJavaVM = 0;
    ifn.GetDefaultJavaVMInitArgs = 0;

    if (!LoadJavaVM(jvmpath, &ifn)) {
        return(6);
    }
    
    return JVMInit(&ifn, threadStackSize, argc, argv, mode, what, ret);
}

jdk\src\solaris\bin\java_md_solinux.c中LoadJavaVM()的核心代码。通过dlopen、dlsym，获取libjvm.so中JNI_CreateJavaVM、JNI_GetDefaultJavaVMInitArgs、JNI_GetCreatedJavaVMs这三个函数的入口，方便后续使用。


jboolean LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)
{
    // 省略部分代码，只保留核心代码

    libjvm = dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL);

    ifn->CreateJavaVM = (CreateJavaVM_t)
        dlsym(libjvm, "JNI_CreateJavaVM");

    ifn->GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t)dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs");

    ifn->GetCreatedJavaVMs = (GetCreatedJavaVMs_t)dlsym(libjvm, "JNI_GetCreatedJavaVMs");

    return JNI_TRUE;
}

jdk\src\solaris\bin\java_md_solinux.c中JVMInit()的核心代码，执行ContinueInNewThread()函数。


int JVMInit(InvocationFunctions* ifn, jlong threadStackSize,
        int argc, char **argv,
        int mode, char *what, int ret)
{
    // 省略部分代码
    return ContinueInNewThread(ifn, threadStackSize, argc, argv, mode, what, ret);
}

jdk\src\share\bin\java.c中ContinueInNewThread()方法的核心代码，执行ContinueInNewThread0()函数。


int ContinueInNewThread(InvocationFunctions* ifn, jlong threadStackSize,
                    int argc, char **argv,
                    int mode, char *what, int ret)
{
      JavaMainArgs args;
      int rslt;

      args.argc = argc;
      args.argv = argv;
      args.mode = mode;
      args.what = what;
      // **在执行完LoadJavaVM()函数后，会将libjvm.so中的JNI_CreateJavaVM、JNI_GetDefaultJavaVMInitArgs、JNI_GetCreatedJavaVMs的函数指针设置到JavaMainArgs中**
      args.ifn = *ifn;

      rslt = ContinueInNewThread0(JavaMain, threadStackSize, (void*)&args);

      return (ret != 0) ? ret : rslt;
}

jdk\src\solaris\bin\java_md_solinux.c中ContinueInNewThread0()核心代码，在创建新的线程，在该线程中执行JavaMain函数，


int
ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) {
    int rslt;int
ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) {
    int rslt;
    // 省略部分代码只保留核心代码
    // **continuation是在线程创建成功后执行的函数指针这里就是JavaMain，执行continuation需要的参数args**
    if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) {
      void * tmp;
      // **线程创建成功后，阻塞待线程执行完毕**
      pthread_join(tid, &tmp);
      rslt = (int)tmp;
    }
    // 省略部分代码只保留核心代码
    pthread_attr_destroy(&attr);
    
    return rslt;

jdk\src\share\bin\java.c中JavaMain()函数核心逻辑。执行InitializeJVM()函数初始化JVM。加载java程序的主类并执行main方法。


int JNICALL JavaMain(void * _args)
{
    JavaMainArgs *args = (JavaMainArgs *)_args;
    // 省略部分代码
    InvocationFunctions ifn = args->ifn;
    // 省略部分代码
    if (!InitializeJVM(&vm, &env, &ifn)) {
        JLI_ReportErrorMessage(JVM_ERROR1);
        exit(1);
    }
    // 省略部分代码
    mainClass = LoadMainClass(env, mode, what);
    // 
    PostJVMInit(env, appClass, vm);
    // 查找到Java程序的public static void main(String[] args)方法
    mainID = (*env)->GetStaticMethodID(env, mainClass, "main", "([Ljava/lang/String;)V");
}

jdk\src\share\bin\java.InitializeJVM()函数核心逻辑。创建并启动JVM。

static jboolean InitializeJVM(JavaVM **pvm, JNIEnv **penv, InvocationFunctions *ifn)
{
    JavaVMInitArgs args;
    jint r;

    memset(&args, 0, sizeof(args));
    // 省略部分代码

    r = ifn->CreateJavaVM(pvm, (void **)penv, &args);
    // 省略部分代码
    return r == JNI_OK;
}

一句话总结流程：

dlopen (把库加载进内存) ➔ dlsym (查找CreateJavaVM函数地址) ➔ 填充 InvocationFunctions ➔ 创建新的的线程 ➔ 在JavaMain函数中调用 CreateJavaVM (点火启动) ，执行Java程序的main(String[] args)方法 。

# linux # jvm # java
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

四天蒸发近2000亿，宇树科技股价近乎“腰斩”；苹果举办库克告别派对：9月1日正式卸任CEO；Anthropic两款新Claude模型曝光 | 极客头条

avatar AI编程社区
cover

Claude Code反超GitHub Copilot登顶第一、90%程序员已用上Agent，最新AI编码调查报告来了

avatar AI编程社区
cover

如何用好 Claude Code 写后端代码

avatar AI编程社区