詳談java命令的本質(zhì)邏輯揭秘

更新時間：2021年05月31日 08:38:54 作者：tera

一個簡單的java命令背后究竟做了些什么事情，很多朋友提出幾個問題，下面帶領(lǐng)大家一起學(xué)習(xí)Java命令的本質(zhì)邏輯問題，感興趣的朋友跟隨小編一起看看吧

前言

在日常編碼中，有了ide的支持，我們已經(jīng)很少直接在命令行中直接執(zhí)行java XXX命令去啟動一個項目了。然而我們有沒有想過，一個簡單的java命令背后究竟做了些什么事情？讓我們看下下面幾個簡單的問題

1.java命令之后可以跟很多參數(shù)，那么這些參數(shù)是如何被解析的？為何-version會返回版本號而如果緊跟一個類名則會啟動jvm？

2.為何我們自己定義的入口方法必須滿足如下的簽名？是否還有其他可能性？

public static void main(String[] args) {
}

3.如果我們需要調(diào)用自己寫的native方法，必須顯式地通過 System.loadLibrary() 加載動態(tài)鏈接庫。而如果我們查看java的基礎(chǔ)類（Thread、Object、Class等，這些類中有非常多的native方法），則會發(fā)現(xiàn)其內(nèi)部并沒有調(diào)用 System.loadLibrary() 方法，而是由靜態(tài)構(gòu)造函數(shù)中的 registerNatives() 負(fù)責(zé)注冊其它的natvie方法。

例如：Thread.java

class Thread implements Runnable {
    private static native void registerNatives();
    static {
        registerNatives();
    }
    ...
}

不過 registerNatives() 本身也是一個native方法，那它所在動態(tài)鏈接庫又是何時被加載的？

問題1和問題2自不必多言，答案一定在java命令中

而對于問題3，因為Thread、Object、Class等等作為jdk的原生類，其相關(guān)的動態(tài)鏈接庫就是jvm本身（windows系統(tǒng)是 jvm.dll ，linux 系統(tǒng)是libjvm.so，mac 系統(tǒng)是 libjvm.dylib），所以很容易推測其加載動態(tài)鏈接庫的過程一定是在jvm的啟動流程中。

今天我們就以上面3個問題為引子，探究一下java命令背后的本質(zhì)，即jvm的啟動流程

jvm的啟動流程分析

既然需要分析jvm的啟動流程，那么jdk和hotspot的源碼是不可少的。下載地址：http://hg.openjdk.java.net/jdk8

主入口方法

查看 java.c，jdk 目錄 /src/java.base/share/native/libjli，該目錄會因為不同版本的jdk有不同

入口方法是 JLI_Launch ，當(dāng)然其中內(nèi)容很多，我們挑選其中的重點部分來看

int
JLI_Launch(args)
{
  ...
  //創(chuàng)建執(zhí)行環(huán)境
  CreateExecutionEnvironment(&argc, &argv,
                               jrepath, sizeof(jrepath),
                               jvmpath, sizeof(jvmpath),
                               jvmcfg,  sizeof(jvmcfg));
  ...
  //加載jvm
  if (!LoadJavaVM(jvmpath, &ifn)) {
        return(6);
  }
  ...
  //解析命令行參數(shù)，例如-h，-version等等
  if (!ParseArguments(&argc, &argv, &mode, &what, &ret, jrepath))
  {
        return(ret);
  }
  ...
  //啟動jvm
  return JVMInit(&ifn, threadStackSize, argc, argv, mode, what, ret);
}

那么接下去就分別查看這幾個主要方法的邏輯

CreateExecutionEnvironment：創(chuàng)建執(zhí)行環(huán)境

這個方法根據(jù)操作系統(tǒng)的不同有不同的邏輯，下面以linux系統(tǒng)為例

查看 java_md_solinux.c，jdk 目錄 /src/java.base/unix/native/libjli

CreateExecutionEnvironment（args) {
    /**
     * 獲取jre的路徑
     */
    if (!GetJREPath(jrepath, so_jrepath, JNI_FALSE) ) {
        JLI_ReportErrorMessage(JRE_ERROR1);
        exit(2);
    }
    JLI_Snprintf(jvmcfg, so_jvmcfg, "%s%slib%s%sjvm.cfg",
                    jrepath, FILESEP, FILESEP, FILESEP);
    /**
     * 讀取jvm的版本，這里是根據(jù)jre的路徑，找到j(luò)vm.cfg文件
     */
    if (ReadKnownVMs(jvmcfg, JNI_FALSE) < 1) {
        JLI_ReportErrorMessage(CFG_ERROR7);
        exit(1);
    }

    jvmpath[0] = '\0';
    /**
     * 檢查jvm的版本，如果命令行中有指定，那么會采用指定的jvm版本，否則使用默認(rèn)的
     */
    jvmtype = CheckJvmType(pargc, pargv, JNI_FALSE);
    if (JLI_StrCmp(jvmtype, "ERROR") == 0) {
        JLI_ReportErrorMessage(CFG_ERROR9);
        exit(4);
    }
    /**
     * 獲取動態(tài)鏈接庫的路徑
     */
    if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, 0 )) {
        JLI_ReportErrorMessage(CFG_ERROR8, jvmtype, jvmpath);
        exit(4);
    }
}

主要有以下幾4個步驟

1.確定jre的路徑

這里會優(yōu)先尋找應(yīng)用程序當(dāng)前目錄

if (GetApplicationHome(path, pathsize)) {
    ...
}

if (GetApplicationHomeFromDll(path, pathsize)) {
    ...
}

2.根據(jù)jre拼接 jvm.cfg 的路徑，并讀取可用的jvm配置

一般 jvm.cfg 文件在 /jre/lib 中，其內(nèi)容如下：

-server KNOWN
-client IGNORE

上述2行配置分別對應(yīng)不同的jvm的版本，例如第一行 -server KNOWN ，那么在加載jvm動態(tài)鏈接庫的時候就會去 /jre/lib/server 目錄中尋找

3.檢查jvm類型

在執(zhí)行java命令的時候，可以通過命令指定jvm版本，如果沒有指定，那么就采用jvm.cfg中的第一個jvm版本

i = KnownVMIndex(arg);
if (i >= 0) {
    ...
}
else if (JLI_StrCCmp(arg, "-XXaltjvm=") == 0 || JLI_StrCCmp(arg, "-J-XXaltjvm=") == 0) {
    ...
}

4.獲取動態(tài)鏈接庫的路徑

根據(jù)前面檢查jvm類型的結(jié)果，獲取到對應(yīng)的jvm動態(tài)鏈接庫的路徑，全部按照默認(rèn)的話，在Mac系統(tǒng)中獲取到的lib路徑如下

路徑中的server正是之前在cfg文件中讀取到的-server

/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/server/libjvm.dylib

LoadJavaVM：加載jvm

查看 java_md_solinux.c，jdk 目錄 /src/java.base/unix/native/libjli

jboolean
LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)
{   
    /**
     * 加載動態(tài)鏈接庫，這里調(diào)用的是dlopen，而不是普通的open
     */
    libjvm = dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL);
    ...
    /**
     * 將jvm中的"JNI_CreateJavaVM"方法鏈接到j(luò)dk的CreateJavaVM方法上
     */
    ifn->CreateJavaVM = (CreateJavaVM_t)
        dlsym(libjvm, "JNI_CreateJavaVM");    
    /**
     * 調(diào)用CreateJavaVM方法
     */
    if (ifn->CreateJavaVM == NULL) {
        JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
        return JNI_FALSE;
    }
		/**
     * 將jvm中的"JNI_GetDefaultJavaVMInitArgs"方法鏈接到j(luò)dk的GetDefaultJavaVMInitArgs方法上
     */
    ifn->GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t)
        dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs");  
    /**
     * 調(diào)用GetDefaultJavaVMInitArgs方法
     */
    if (ifn->GetDefaultJavaVMInitArgs == NULL) {
        JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
        return JNI_FALSE;
    }
		/**
     * 將jvm中的"JNI_GetCreatedJavaVMs"方法鏈接到j(luò)dk的GetCreatedJavaVMs方法上
     */
    ifn->GetCreatedJavaVMs = (GetCreatedJavaVMs_t)
        dlsym(libjvm, "JNI_GetCreatedJavaVMs");  
    /**
     * 調(diào)用GetCreatedJavaVMs方法
     */
    if (ifn->GetCreatedJavaVMs == NULL) {
        JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
        return JNI_FALSE;
    }
}

主要步驟如下：

1.加載動態(tài)鏈接庫，也正是我們第一個問題的答案所在

dlopen方法是dynamic link open的縮寫，在打開文件的同時，加載動態(tài)鏈接庫?？梢酝ㄟ^ man dlopen 命令查看說明

man dlopen
dlopen -- load and link a dynamic library or bundle

2.鏈接并調(diào)用jvm中的 JNI_CreateJavaVM 、GetDefaultJavaVMInitArgs、GetCreatedJavaVMs

dlsym方法是dynamic link symbol的縮寫，將動態(tài)鏈接庫中的方法鏈接到當(dāng)前方法上

man dlsym
dlsym -- get address of a symbol

這3個方法顧名思義，分別是創(chuàng)建jvm、獲取默認(rèn)的jvm啟動參數(shù)、獲取創(chuàng)建完成的jvm。這3個方法的入口在

hotspot 目錄 /src/share/vm/prims/jni.cpp

文件中，有興趣的同學(xué)可以自行查看

ParseArguments：解析命令行參數(shù)

查看 java.c，jdk 目錄 /src/java.base/share/native/libjli

static jboolean
ParseArguments(int *pargc, char ***pargv,
               int *pmode, char **pwhat,
               int *pret, const char *jrepath)
{
  ...
  if (JLI_StrCmp(arg, "--version") == 0) {
      printVersion = JNI_TRUE;
      printTo = USE_STDOUT;
      return JNI_TRUE;
  }
  ...
  if (JLI_StrCCmp(arg, "-ss") == 0 ||
              JLI_StrCCmp(arg, "-oss") == 0 ||
              JLI_StrCCmp(arg, "-ms") == 0 ||
              JLI_StrCCmp(arg, "-mx") == 0) {
      char *tmp = JLI_MemAlloc(JLI_StrLen(arg) + 6);
      sprintf(tmp, "-X%s", arg + 1); /* skip '-' */
      AddOption(tmp, NULL);
  }
  ...
}

其中的參數(shù)一共有2大類。

1.類似于 --version 的參數(shù)在解析之后會直接返回

2.類似于 -mx、-mx 的參數(shù)則會通過 AddOption 方法添加成為 VM option

/*
 * Adds a new VM option with the given name and value.
 */
void
AddOption(char *str, void *info)
{
  ...
}

JVMInit：啟動jvm

查看 java_md_solinux.c，jdk 目錄 /src/java.base/unix/native/libjli

JVMInit(InvocationFunctions* ifn, jlong threadStackSize,
        int argc, char **argv,
        int mode, char *what, int ret)
{
    //在一個新線程中啟動jvm
    return ContinueInNewThread(ifn, threadStackSize, argc, argv, mode, what, ret);
}

在該方法中，會調(diào)用 ContinueInNewThread 創(chuàng)建一個新線程啟動jvm

查看 java.c，jdk 目錄 /src/java.base/share/native/libjli

int
ContinueInNewThread(InvocationFunctions* ifn, jlong threadStackSize,
                    int argc, char **argv,
                    int mode, char *what, int ret)
{
  ...
  /**
   * 創(chuàng)建一個新的線程創(chuàng)建jvm并調(diào)用main方法
   */
  rslt = ContinueInNewThread0(JavaMain, threadStackSize, (void*)&args);
  return (ret != 0) ? ret : rslt;
}

在該方法中，會調(diào)用 ContinueInNewThread0 并傳入 JavaMain 入口方法

查看 java_md_solinux.c，jdk 目錄 /src/java.base/unix/native/libjli

/**
 * 阻塞當(dāng)前線程，并在一個新線程中執(zhí)行main方法
 */
int
ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) {
    //創(chuàng)建一個新線程執(zhí)行傳入的continuation，其實也就是外面?zhèn)魅氲膍ain方法
    if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) {
      void * tmp;
      //當(dāng)前線程阻塞
      pthread_join(tid, &tmp);
      rslt = (int)(intptr_t)tmp;
    }
    ...
}

在該方法中，會創(chuàng)建一個新線程調(diào)用傳入的 main 方法，而當(dāng)前線程則阻塞

因為這里pthread_join是等待在運行main方法的線程上，所以java程序運行時，如果main線程運行結(jié)束了，整個進程就會結(jié)束，而由main啟動的子線程對整個進程是沒有影響的

查看 java.c，jdk 目錄 /src/java.base/share/native/libjli

int JNICALL
JavaMain(void * _args)
{
  //啟動jvm
  if (!InitializeJVM(&vm, &env, &ifn)) {
      JLI_ReportErrorMessage(JVM_ERROR1);
      exit(1);
  }
  ...
  //加載主類
  mainClass = LoadMainClass(env, mode, what);
  //找到main方法id
  mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                                       "([Ljava/lang/String;)V");
  //通過jni回調(diào)java代碼中的main方法
  (*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);
}

這里對于main方法的方法名和簽名都是固定判斷的，所以無論是什么java程序，入口方法必須是 public static void main(String[] args)

到此jvm從準(zhǔn)備啟動到最后執(zhí)行main方法的代碼流程就結(jié)束了。因為這個流程的方法分散在不同的文件中，會很讓人頭暈，所以我總結(jié)了成了以下結(jié)構(gòu)，方便大家理解

入口方法：JLI_Launch

        |--------->創(chuàng)建執(zhí)行環(huán)境：CreateExecutionEnvironment

        |          |--------->獲取jre的路徑：GetJREPath

        |          |--------->讀取jvm配置：ReadKnownVMs

        |          |--------->檢查jvm類型：CheckJvmType

        |          |--------->獲取jvm動態(tài)鏈接庫路徑：GetJVMPath 

        |--------->加載jvm動態(tài)鏈接庫：LoadJavaVM

        |          |--------->加載動態(tài)鏈接庫：dlopen

        |          |--------->鏈接jvm方法：dlsym

        |--------->解析命令行參數(shù)：ParseArguments

        |          |--------->類似于 --version 的參數(shù)在解析之后會直接返回

        |          |--------->類似于 -mx、-mx 的參數(shù)則會通過 AddOption 方法添加成為 VM option

        |--------->啟動jvm并執(zhí)行main方法：JVMInit       

                   |--------->創(chuàng)建一個新線程并執(zhí)行后續(xù)任務(wù)：ContinueInNewThread

                               |--------->創(chuàng)建新線程執(zhí)行main方法：ContinueInNewThread0(JavaMain)

                                 			|--------->創(chuàng)建新線程，用于執(zhí)行傳入的main方法：pthread_create

                                 			|--------->阻塞當(dāng)前線程：pthread_join

                               |--------->獲取main方法：JavaMain

                                 			|--------->加載主類：LoadMainClass

                                 			|--------->根據(jù)簽名獲取main方法的id：GetStaticMethodID

                                 			|--------->執(zhí)行main方法：CallStaticVoidMethod

以上就是java命令的本質(zhì)邏輯揭秘的詳細(xì)內(nèi)容，更多關(guān)于java命令的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: