### 1. 前言 上文介紹了HotSpot編譯和除錯的方法，而這篇文章將邁出正式除錯的第一步——除錯HotSpot的啟動過程。 學習啟動過程可以幫助我們瞭解程式的入口，並對虛擬機器的執行有個整體的把握，方便日後深入學習具體的一些模組。 ### 2. 整體感知啟動過程 整體的感知啟動過程可以在啟動時新增`_JAVA_LAUNCHER_DEBUG=1`的環境變數。這樣JVM會輸出詳細的列印。 通過這些列印，我們大致能瞭解到啟動過程發生了什麼。 ``` ----_JAVA_LAUNCHER_DEBUG---- Launcher state: debug:on javargs:off program name:java launcher name:openjdk javaw:off fullversion:1.8.0-internal-debug-xieshang_2020_12_18_09_49-b00 dotversion:1.8 ergo_policy:DEFAULT_ERGONOMICS_POLICY Command line args: argv[0] = /home/xieshang/learn-jvm/openjdk/build/linux-x86_64-normal-server-slowdebug/jdk/bin/java argv[1] = com.insanexs/HelloHotspot JRE path is /home/xieshang/learn-jvm/openjdk/build/linux-x86_64-normal-server-slowdebug/jdk jvm.cfg[0] = ->-server<- jvm.cfg[1] = ->-client<- 1 micro seconds to parse jvm.cfg Default VM: server Does `/home/xieshang/learn-jvm/openjdk/build/linux-x86_64-normal-server-slowdebug/jdk/lib/amd64/server/libjvm.so' exist ... yes. mustsetenv: FALSE JVM path is /home/xieshang/learn-jvm/openjdk/build/linux-x86_64-normal-server-slowdebug/jdk/lib/amd64/server/libjvm.so 1 micro seconds to LoadJavaVM JavaVM args: version 0x00010002, ignoreUnrecognized is JNI_FALSE, nOptions is 5 option[ 0] = '-Dsun.java.launcher.diag=true' option[ 1] = '-Djava.class.path=/home/xieshang/learn-open-jdk' option[ 2] = '-Dsun.java.command=com.insanexs/HelloHotspot' option[ 3] = '-Dsun.java.launcher=SUN_STANDARD' option[ 4] = '-Dsun.java.launcher.pid=4485' 1 micro seconds to InitializeJVM Main class is 'com.insanexs/HelloHotspot' App's argc is 0 1 micro seconds to load main class ----_JAVA_LAUNCHER_DEBUG---- ``` 從上面的列印大致可以看出有這麼幾步： 1. 列印了啟動器的狀態，包括版本號、程式名等 2. 列印了傳給程式命令列引數，第一個是java命令的相信路徑，第二個虛擬機器將要執行的java程式碼 3. 解析JRE路徑，解析jvm.cfg 4. 載入libjvm庫 5. 解析虛擬機器引數 6. 初始化虛擬機器 7. 虛擬機器載入要執行的Java主類，解析引數並執行 ### 3. 啟動過程說明 我們就以上面劃分的階段為整體脈絡，再深入的看看各階段的具體邏輯。 #### 3.1 啟動入口 虛擬機器程式執行的入口是在main.c/main方法中。之後會呼叫java.c/JLI_Launch方法。 ``` 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 */ ) { /************************** 前期初始化工作和狀態列印 ********************/ int mode = LM_UNKNOWN; char *what = NULL; char *cpath = 0; char *main_class = NULL; int ret; InvocationFunctions ifn; //和建立虛擬機器相關的結構體 指向三個關鍵的函式 jlong start, end; char jvmpath[MAXPATHLEN]; char jrepath[MAXPATHLEN]; char jvmcfg[MAXPATHLEN]; _fVersion = fullversion; _dVersion = dotversion; _launcher_name = lname; _program_name = pname; _is_java_args = javaargs; _wc_enabled = cpwildcard; _ergo_policy = ergo; InitLauncher(javaw); DumpState(); //列印相關狀態 //列印引數 if (JLI_IsTraceLauncher()) { int i; printf("Command line args:\n"); for (i = 0; i < argc ; i++) { printf("argv[%d] = %s\n", i, argv[i]); } AddOption("-Dsun.java.launcher.diag=true", NULL); } /************************** 檢驗版本 ********************/ /* * Make sure the specified version of the JRE is running. * * There are three things to note about the SelectVersion() routine: * 1) If the version running isn't correct, this routine doesn't * return (either the correct version has been exec'd or an error * was issued). * 2) Argc and Argv in this scope are *not* altered by this routine. * It is the responsibility of subsequent code to ignore the * arguments handled by this routine. * 3) As a side-effect, the variable "main_class" is guaranteed to * be set (if it should ever be set). This isn't exactly the * poster child for structured programming, but it is a small * price to pay for not processing a jar file operand twice. * (Note: This side effect has been disabled. See comment on * bugid 5030265 below.) */ SelectVersion(argc, argv, &main_class); //版本檢測 /************************** 建立執行環境 ********************/ CreateExecutionEnvironment(&argc, &argv, jrepath, sizeof(jrepath), jvmpath, sizeof(jvmpath), jvmcfg, sizeof(jvmcfg));//解析相關環境 獲取jre路徑、jvmlib庫和jvm.cfg /************************** 設定虛擬機器環境 ********************/ if (!IsJavaArgs()) { SetJvmEnvironment(argc,argv); } ifn.CreateJavaVM = 0; ifn.GetDefaultJavaVMInitArgs = 0; if (JLI_IsTraceLauncher()) { start = CounterGet(); } /************************** 載入虛擬機器 ********************/ if (!LoadJavaVM(jvmpath, &ifn)) { //載入 主要是從jvmlib庫中解析函式地址 賦值給ifn return(6); } if (JLI_IsTraceLauncher()) { end = CounterGet(); } JLI_TraceLauncher("%ld micro seconds to LoadJavaVM\n", (long)(jint)Counter2Micros(end-start)); ++argv; --argc; if (IsJavaArgs()) { /* Preprocess wrapper arguments */ TranslateApplicationArgs(jargc, jargv, &argc, &argv); if (!AddApplicationOptions(appclassc, appclassv)) { return(1); } } else { /* Set default CLASSPATH */ cpath = getenv("CLASSPATH"); //新增CLASSPATH if (cpath == NULL) { cpath = "."; } SetClassPath(cpath); } /************************** 解析引數 ********************/ /* Parse command line options; if the return value of * ParseArguments is false, the program should exit. */ if (!ParseArguments(&argc, &argv, &mode, &what, &ret, jrepath)) { return(ret); } /* Override class path if -jar flag was specified */ if (mode == LM_JAR) { //如果是java -jar 則覆蓋classpath SetClassPath(what); /* Override class path */ } /* set the -Dsun.java.command pseudo property */ //解析特殊屬性 SetJavaCommandLineProp(what, argc, argv); /* Set the -Dsun.java.launcher pseudo property */ SetJavaLauncherProp(); /* set the -Dsun.java.launcher.* platform properties */ SetJavaLauncherPlatformProps(); /************************** 初始化虛擬機器 ********************/ return JVMInit(&ifn, threadStackSize, argc, argv, mode, what, ret); } ``` 這個方法比較長，但是可以劃分為幾個部分去分析： ##### 3.1.1 前期初始化工作和狀態列印 這裡的初始化部分包括一些引數值的宣告，特殊結構體`InvocationFuntions`的宣告，啟動器的初始化。 其中宣告的引數會在後續的啟動過程用來儲存相關資訊，例如儲存JVM、JRE相關路徑等。 `InvocationFuntions`是個重要的結構體，其中包含了建立JVM會被呼叫的三個函式指標。 ``` typedef struct { CreateJavaVM_t CreateJavaVM; //指向負責建立JavaVM和JNIEnv結構的函式指標 GetDefaultJavaVMInitArgs_t GetDefaultJavaVMInitArgs; //指向獲取預設JVM初始引數的函式指標 GetCreatedJavaVMs_t GetCreatedJavaVMs; //指向獲取JVM的函式指標 } InvocationFunctions; ``` `InitLaucher`方法主要就是根據`_JAVA_LAUNCHER_DEBUG`這個環境變數會決定後續是否輸出DEBUG的列印。 在開啟了launcher_debug後，`DumpState()`方法會打印出啟動狀態，並且之後打印出命令列引數。 ##### 3.1.2 檢驗版本 `SelectVersion`會驗證使用者指定的java版本和實際執行的java版本是否相容，如果不相容會退出程序。使用者可以通過`_JAVA_VERSION_SET`的環境變數或是jar包中manifest檔案等方式指定執行的java版本。 ##### 3.1.3 建立執行環境 `CreateExecutionEnvironment`會為後續的啟動建立執行環境，這一步驟中主要是確定jdk所在的路徑，解析jvmcfg和確認libjvm是否存在等。 1. 主要是根據處理器型別和主路徑確定出JRE的路徑 2. 以同樣的方式確定jvm.cfg的檔案位置，並解析jvm.cfg（jvm.cfg裡面是一些虛擬機器的預設配置，如常見的指定以客戶端或服務端模式執行） 3. 檢查虛擬機器型別(-server/-client)，可以是jvm.cfg指定或是由啟動引數指定 4. 確定libjvm庫的位置，校驗庫是否存在，這個庫核心的函式庫 ##### 3.1.4 設定虛擬機器環境 `SetJvmEnviroment`主要解析NativeMemoryTracking引數，可以用來追蹤本地記憶體的使用情況 ##### 3.1.5 載入虛擬機器 前期環境準備好之後，`LoadJavaVM()`會從之前確定的路徑，載入libjvm庫，並將其中的庫中`JNI_CreateJavaVM`,`JNI_GetDefaultJavaVMInitArgs`和`JNI_GetCreatedJavaVMs`三個函式賦值給ifn。 這三個函式會在之後建立虛擬機器時被使用。 ##### 3.1.6 解析引數 這裡有兩個部分，一是解析命令列傳入的引數，看是否有特定的JVM配置選項。這些引數會被用於後續虛擬機器的建立上。這一過程主要發生在`ParseArguments()`中。另一個部分就是新增一些特定的虛擬機器引數，發生在`SetJavaCommandLineProp`、`SetJavaLaucherProp`和`SetJavaLaucherPlatformProps`中。 ##### 3.1.7 虛擬機器初始化 在環境都準備好之後，會由`JVMInit()`執行虛擬機器初始化工作，首先會通過`ShowSplashScreen()`方法載入啟動動畫，之後會進入`CountinueInNewThread()`方法，由新的執行緒負責建立虛擬機器的工作。 #### 3.2 在新執行緒中繼續虛擬機器的建立 通過上文的介紹，我們找到了`java.c/ConutinueInNewThread()`的方法。這個方法分為兩個部分，第一部分就是確定執行緒棧的深度，第二部分就是由`ContinueInNewThread0()`這個方法實現真正的虛擬機器建立過程。 ``` int ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) { int rslt; #ifndef __solaris__ pthread_t tid; //宣告執行緒屬性 pthread_attr_t attr; //初始化執行緒屬性並設定相關屬性值 pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); //設定執行緒棧深度 if (stack_size > 0) { pthread_attr_setstacksize(&attr, stack_size); } //建立執行緒並執行方法 if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) { //建立執行緒 並將執行函式的起始地址和執行引數傳入 void * tmp; pthread_join(tid, &tmp);//阻塞當前執行緒 等待新執行緒執行結束返回 rslt = (int)tmp; } else { /* * Continue execution in current thread if for some reason (e.g. out of * memory/LWP) a new thread can't be created. This will likely fail * later in continuation as JNI_CreateJavaVM needs to create quite a * few new threads, anyway, just give it a try.. */ rslt = continuation(args); } pthread_attr_destroy(&attr); #else /* __solaris__ */ thread_t tid; long flags = 0; if (thr_create(NULL, stack_size, (void *(*)(void *))continuation, args, flags, &tid) == 0) { void * tmp; thr_join(tid, NULL, &tmp); rslt = (int)tmp; } else { /* See above. Continue in current thread if thr_create() failed */ rslt = continuation(args); } #endif /* !__solaris__ */ return rslt; } ``` 在這個方法中，首先呼叫了`pthread_create()`函式建立了一個新執行緒，同時舊執行緒被jion等待新執行緒執行完成後返回。 `pthread_create()`是unix作業系統建立執行緒的函式，它的第一個引數表示執行緒標識，第二引數表示執行緒屬性，第三個引數表示建立執行緒所要執行函式的地址，第四個引數則是將要執行的函式的引數。 等到新執行緒執行完成後，舊的執行緒也會返回。此時說明執行結束，程序將會退出。 需要注意的是此時傳入的函式地址，它是指向`java.c/JavaMain()`函式。也就是說新建立的執行緒將會開始執行該函式。 #### 3.3 虛擬機器建立、Java程式執行的主過程——JavaMain 新建立的執行緒會去執行`JavaMain()`函式，正式進入了建立虛擬機器、執行Java程式碼的過程。 ``` int JNICALL JavaMain(void * _args) { /*********************獲取相關引數****************************/ JavaMainArgs *args = (JavaMainArgs *)_args; int argc = args->argc; char **argv = args->argv; int mode = args->mode; char *what = args->what; InvocationFunctions ifn = args->ifn; JavaVM *vm = 0; JNIEnv *env = 0; jclass mainClass = NULL; jclass appClass = NULL; // actual application class being launched jmethodID mainID; jobjectArray mainArgs; int ret = 0; jlong start, end; RegisterThread(); /*******************初始化JVM、列印相關資訊********************************/ start = CounterGet(); if (!InitializeJVM(&vm, &env, &ifn)) { JLI_ReportErrorMessage(JVM_ERROR1); exit(1); } if (showSettings != NULL) { ShowSettings(env, showSettings); CHECK_EXCEPTION_LEAVE(1); } if (printVersion || showVersion) { PrintJavaVersion(env, showVersion); CHECK_EXCEPTION_LEAVE(0); if (printVersion) { LEAVE(); } } /* If the user specified neither a class name nor a JAR file */ if (printXUsage || printUsage || what == 0 || mode == LM_UNKNOWN) { PrintUsage(env, printXUsage); CHECK_EXCEPTION_LEAVE(1); LEAVE(); } FreeKnownVMs(); /* after last possible PrintUsage() */ if (JLI_IsTraceLauncher()) { end = CounterGet(); JLI_TraceLauncher("%ld micro seconds to InitializeJVM\n", (long)(jint)Counter2Micros(end-start)); } /* At this stage, argc/argv have the application's arguments */ //列印Java程式的引數 if (JLI_IsTraceLauncher()){ int i; printf("%s is '%s'\n", launchModeNames[mode], what); printf("App's argc is %d\n", argc); for (i=0; i < argc; i++) { printf(" argv[%2d] = '%s'\n", i, argv[i]); } } /******************獲取Java程式的主類***************************/ ret = 1; /* * Get the application's main class. * * See bugid 5030265. The Main-Class name has already been parsed * from the manifest, but not parsed properly for UTF-8 support. * Hence the code here ignores the value previously extracted and * uses the pre-existing code to reextract the value. This is * possibly an end of release cycle expedient. However, it has * also been discovered that passing some character sets through * the environment has "strange" behavior on some variants of * Windows. Hence, maybe the manifest parsing code local to the * launcher should never be enhanced. * * Hence, future work should either: * 1) Correct the local parsing code and verify that the * Main-Class attribute gets properly passed through * all environments, * 2) Remove the vestages of maintaining main_class through * the environment (and remove these comments). * * This method also correctly handles launching existing JavaFX * applications that may or may not have a Main-Class manifest entry. */ mainClass = LoadMainClass(env, mode, what);//載入mainClass CHECK_EXCEPTION_NULL_LEAVE(mainClass); /* * In some cases when launching an application that needs a helper, e.g., a * JavaFX application with no main method, the mainClass will not be the * applications own main class but rather a helper class. To keep things * consistent in the UI we need to track and report the application main class. */ appClass = GetApplicationClass(env); //獲取application class NULL_CHECK_RETURN_VALUE(appClass, -1); /* * PostJVMInit uses the class name as the application name for GUI purposes, * for example, on OSX this sets the application name in the menu bar for * both SWT and JavaFX. So we'll pass the actual application class here * instead of mainClass as that may be a launcher or helper class instead * of the application class. */ PostJVMInit(env, appClass, vm); // JVM 初始化後置處理 /* * The LoadMainClass not only loads the main class, it will also ensure * that the main method's signature is correct, therefore further checking * is not required. The main method is invoked here so that extraneous java * stacks are not in the application stack trace. */ /******************找主類的main方法************************/ mainID = (*env)->GetStaticMethodID(env, mainClass, "main", "([Ljava/lang/String;)V"); //獲取main class的 main(String[] args)方法 CHECK_EXCEPTION_NULL_LEAVE(mainID); /*******************封裝引數，呼叫main方法*****************/ /* Build platform specific argument array */ mainArgs = CreateApplicationArgs(env, argv, argc); //封裝 main(String[] args) 方法的引數args CHECK_EXCEPTION_NULL_LEAVE(mainArgs); /* Invoke main method. */ (*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs); //呼叫main(String args)方法 /* * The launcher's exit code (in the absence of calls to * System.exit) will be non-zero if main threw an exception. */ /*******************獲取執行結果 並退出虛擬機器**************/ ret = (*env)->ExceptionOccurred(env) == NULL ? 0 : 1; //根據是否有異常 確定退出碼 LEAVE(); //執行緒解綁 銷燬JVM } ``` ##### 3.3.1 引數解析 之前上文解析得到的命令列引數等都被封裝在`JavaMainArgs`結構體中，傳給了`JavaMain`方法。因此需要從這個結構體中取回引數。 另外，還建立了一些變數用於之後的過程中儲存值，譬如jclass，jmethodID等。 ##### 3.3.2 初始化虛擬機器，列印相關資訊 上述程式碼中的`InitializeJVM()`方法會負責虛擬機器的初始化過程。其程式碼如下： ``` static jboolean InitializeJVM(JavaVM **pvm, JNIEnv **penv, InvocationFunctions *ifn) { JavaVMInitArgs args; jint r; memset(&args, 0, sizeof(args)); args.version = JNI_VERSION_1_2; args.nOptions = numOptions; args.options = options; args.ignoreUnrecognized = JNI_FALSE; if (JLI_IsTraceLauncher()) { int i = 0; printf("JavaVM args:\n "); printf("version 0x%08lx, ", (long)args.version); printf("ignoreUnrecognized is %s, ", args.ignoreUnrecognized ? "JNI_TRUE" : "JNI_FALSE"); printf("nOptions is %ld\n", (long)args.nOptions); for (i = 0; i < numOptions; i++) printf(" option[%2d] = '%s'\n", i, args.options[i].optionString); } r = ifn->CreateJavaVM(pvm, (void **)penv, &args); //通過ifn的函式指標 呼叫CreateJavaVM函式初始化JavaVM 和 JNIEnv JLI_MemFree(options); return r == JNI_OK; } ``` 先獲取虛擬機器引數，在通過ifn結構體中CreateJavaVM指標，呼叫正式建立Java虛擬機器的函式`JNI_CreateJavaVM`。 `JNI_CreateJavaVM`程式碼的主要流程如下： 1. 先由`Threads::create_vm()`方法建立虛擬機器 2. 給兩個重要的指標賦值，分別是JavaVM * 和 JNIEnv 3. 一些後置處理，例如通過JVMTI（可以說是虛擬機器的工具介面，提供了對虛擬機器除錯、監測等等的功能）、事件提交等 針對第一點，`Threads::create_vm()`是負責建立虛擬機器，整個過程相對複雜，需要初始化很多模組，建立虛擬機器的後臺執行緒，載入必要的類等等，這裡不做深入分析。之後有時間可以單獨分析這一過程。 針對第二點中提到的兩個資料結構，非常重要。我們可以看看它們的具體的內容。 ###### JavaVM JavaVM結構內部包的是`JNIInvokeInterface_`結構，因此我們直接看一下`JNIInvokeInterface_`的結構 ``` struct JNIInvokeInterface_ { //預留欄位 void *reserved0; void *reserved1; void *reserved2; jint (JNICALL *DestroyJavaVM)(JavaVM *vm); //銷燬虛擬機器的函式指標 jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args); //繫結執行緒的函式指標 jint (JNICALL *DetachCurrentThread)(JavaVM *vm); //解綁執行緒的函式指標 jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version); //獲取JNIEnv結構的函式指標 jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);//將執行緒轉為後臺執行緒 }; ``` 可以看到主要是一些和虛擬機器操作的相關函式。 ###### JNIEnv `JNIEnv`結構內部包的是JNINativeInterface結構，這個結構同樣定義了很多函式指標，程式碼太長，這裡就不直接貼出了。有興趣的可以在`jni.h`中自行檢視。如果對結構中的方法分類的話，可以分成以下幾類： - 獲取虛擬機器資訊 - 獲取相關類和方法，方法執行 - 獲取/設定物件欄位 - 靜態方法、靜態變數的獲取與設定 - 常見型別的物件的建立和釋放 - 建立直接記憶體、訪問鎖等 總之，提供了通過C++程式碼訪問Java程式的能力（這對於從事JNI開發的人來說十分重要）。 ##### 3.3.3 確定Java程式的主類 瞭解完成虛擬機器的初始化過程後，再回到JavaMain()方法中，之後是通過`LoadMainClass()`或`GetApplicationClass()`方法確定Java程式碼的主類。 如果我們在執行指定了Java類，那麼這個類就是主類。這裡還會呼叫`LauncherHelper.checkAndLoadMain()`檢驗主類是否合法。`LauncherHelper`的Java程式碼，這裡就是上面介紹的JNIEnv的能力在C++的程式碼中執行Java程式碼。 對於一些沒有主類的程式，需要通過`LaucherHelper.getApplicationClass()`確定程式類。 ##### 3.3.4 從主類中獲取main方法的methodID，並呼叫方法 再確定了mainClass之後，還需要找到該類定義的`main()`，獲取main()方法，然後將程式引數封裝，傳遞給`main()`執行，執行緒會以此為入口，開始執行Java程式。 這裡的找方法和執行方法同樣是依賴了JNIEnv中`GetStaticMethodID`和`CallStaticVoidMethod`。 所以我們的main()方法總是`static void`的。 ##### 3.3.5 獲取執行結果，退出虛擬機器 當執行緒從Main()方法中返回，說明Java程式已經執行完成(或是異常退出)，這時候虛擬機器會檢查執行結果，並解綁執行緒銷燬虛擬機器，最終退