深入理解Java之jvm启动流程

jvm是java的核心运行平台，自然是个非常复杂的系统。当然了，说jvm是个平台，实际上也是个泛称。准确的说，它是一个java虚拟机的统称，它并不指具体的某个虚拟机。所以，谈到java虚拟机时，往往我们通常说的都是一些规范性质的东西。

那么，如果想要研究jvm是如何工作的，就不能是泛泛而谈了。我们必须要具体到某个指定的虚拟机实现，以便说清其过程。

1. 说说openjdk

因为java实际上已经被oracle控制，而oracle本身是个商业公司，所以从某种程度上说，这里的java并不是完全开源的。我们称官方的jdk为oraclejdk. 或者叫 hotspot vm

与此同时，社区维护了一个完全开源的版本，openjdk。这两个jdk实际上，大部分是相同的，只是维护的进度不太一样，以及版权归属不一样。

所以，如果想研究jvm的实现，那么基于openjdk来做，是比较明智的选择。

如果想了解openjdk是如何设计的，以及它有什么高级特性，以及各种最佳实践，那么买一本书是最佳选择。

如果业有余力，想去了解了解源码的，那么可以到官网查看源码。openjdk8的源码地址为: 因为是国外网站的原因，速度不会很快。所以只是在网站上查看源码，还是有点累的。另外，没有ide的帮助，估计很少有人能够坚持下去。另外的下载地址，大家可以网上搜索下，资源总是有的，国人链接速度快。多花点心思找找。

当然要说明的一点是：一个没有设计背景，没有框架概念的源码阅读，都是而流氓。那样的工作，就像是空中楼阁，并不让人踏实。

2. 谈谈c语言

c语言，一般作为我们的大学入门语言，或多或少都接触过。但要说精通，可能就是很少一部分人了。但我要说的是，只要学过c语言，对于大部分的程序阅读，基本上就不是问题了。

openjdk的实现中，其核心的一部分就是使用c语言写的，当然其他很多语言也是一样的。所以，c语言相当重要，在底层的世界里。这里只是说它重要，但并不代表它就一定最厉害，即不是写c语言的gg就比写java的jj厉害了。因为，工作不分高低，语言同样。只是各有所长罢了。重点不是在这里，在于思想。

c语言的编程几大流程：写代码（最核心）、编译、链接（最麻烦）、运行。

当然，最核心的自然是写代码。不对，最核心的是：做设计。

c语言中，以一个main()函数为入口，编写各种逻辑后，通过调用和控制main()方法，实现各种复杂逻辑。

所以，要研究一个项目，首先就是要找到其入口。然后根据目的，再进行各功能实现的通路学习。

c语言有极其灵活的语法，超级复杂的指针设计，以及各类似面向对象思想的结构体，以及随时可能操作系统获取信息的能力（各种链接）。所以，导致c语言有时确实比较难以读懂。这也是没办法的事，会很容易，精却很难。这是亘古不变的道理。是一个选择题，也是一道应用题。

一句话，会一点，就够吃瓜群众使用了。

3. openjdk的入口

上面说到，要研究一个c项目，首要就是找到其入口。那么，openjdk的入口在哪呢？

是在 share/bin/main.c 中，main()方法就是其入口。这个文件命名，够清晰了吧，明眼人一看就知道了。哈哈，不过一般地，我们还是需要通过查资料才知晓。

main.c是jvm的唯一main方法入口，其中，jdk被编译出来之后，会有许多的工作箱，如jmap,jps,jstack.... 这些工具箱的入口，实际也是这个main, 只是它们包含了不同的子模块，从而达到不同工具的目的。

main.c的内容也不多，主要它也只是一个框架，为屏蔽各系统的差异。它的存在，主要是为引入 jli_launch() 方法，相当于定义自己的main()方法。

/*
 * this file contains the main entry point into the launcher code
 * this is the only file which will be repeatedly compiled by other
 * tools. the rest of the files will be linked in.
 */
#include "defines.h"
#ifdef _msc_ver
#if _msc_ver > 1400 && _msc_ver < 1600
/*
 * when building for microsoft windows, main has a dependency on msvcr??.dll.
 *
 * when using visual studio 2005 or 2008, that must be recorded in
 * the [java,javaw].exe.manifest file.
 *
 * as of vs2010 (ver=1600), the runtimes again no longer need manifests.
 *
 * reference:
 * c:/program files/microsoft sdks/windows/v6.1/include/crtdefs.h
 */
#include <crtassem.h>
#ifdef _m_ix86
#pragma comment(linker,"/manifestdependency:\"type='win32' " \
 "name='" __libraries_assembly_name_prefix ".crt' " \
 "version='" _crt_assembly_version "' "  \
 "processorarchitecture='x86' "   \
 "publickeytoken='" _vc_assembly_publickeytoken "'\"")
#endif /* _m_ix86 */
//this may not be necessary yet for the windows 64-bit build, but it
//will be when that build environment is updated. need to test to see
//if it is harmless:
#ifdef _m_amd64
#pragma comment(linker,"/manifestdependency:\"type='win32' " \
 "name='" __libraries_assembly_name_prefix ".crt' " \
 "version='" _crt_assembly_version "' "  \
 "processorarchitecture='amd64' "  \
 "publickeytoken='" _vc_assembly_publickeytoken "'\"")
#endif /* _m_amd64 */
#endif /* _msc_ver > 1400 && _msc_ver < 1600 */
#endif /* _msc_ver */
/*
 * entry point.
 */
// 定义入口函数，javaw模式下使用 winmain(), 否则使用 main()
#ifdef javaw
char **__initenv;
int winapi
winmain(hinstance inst, hinstance previnst, lpstr cmdline, int cmdshow)
{
 int margc;
 char** margv;
 const jboolean const_javaw = jni_true;
 __initenv = _environ;
#else /* javaw */
int
main(int argc, char **argv)
{
 int margc;
 char** margv;
 const jboolean const_javaw = jni_false;
#endif /* javaw */
#ifdef _win32
 // windows下的参数获取
 {
 int i = 0;
 if (getenv(jldebug_env_entry) != null) {
 printf("windows original main args:\n");
 for (i = 0 ; i < __argc ; i++) {
 printf("wwwd_args[%d] = %s\n", i, __argv[i]);
 }
 }
 }
 jli_cmdtoargs(getcommandline());
 margc = jli_getstdargc();
 // add one more to mark the end
 margv = (char **)jli_memalloc((margc + 1) * (sizeof(char *)));
 {
 int i = 0;
 stdarg *stdargs = jli_getstdargs();
 for (i = 0 ; i < margc ; i++) {
 margv[i] = stdargs[i].arg;
 }
 margv[i] = null;
 }
#else /* *nixes */
 // 各种linux平台上的参数，直接取自main入参
 margc = argc;
 margv = argv;
#endif /* win32 */
 // 核心: 重新定义入口方法为: jli_launch()
 return jli_launch(margc, margv,
  sizeof(const_jargs) / sizeof(char *), const_jargs,
  sizeof(const_appclasspath) / sizeof(char *), const_appclasspath,
  full_version,
  dot_version,
  (const_progname != null) ? const_progname : *margv,
  (const_launcher != null) ? const_launcher : *margv,
  (const_jargs != null) ? jni_true : jni_false,
  const_cpwildcard, const_javaw, const_ergo_class);
}

因为java语言被设计成跨平台的语言，那么如何跨平台呢？因为平台差异总是存在的，如果语言本身不关注平台，那么自然是有人在背后关注了平台，从而屏蔽掉了差异。是了，这就是虚拟机存在的意义。因此，在入口方法，我们就可以看到，它一上来就关注平台差异性。这是必须的。

4. openjdk的启动流程

有了上面的入口知识，好像是明白了一些道理。但是好像还是没有达到要理解启动过程的目的。不急，且听我慢慢道来。

我们启动一个虚拟机时，一般是使用 java -classpath:xxx <other-options> xx.xx , 或者是 java -jar <other-options> xx.jar 。 具体怎么用无所谓，重点是我们都是 java这个应用程序启动的虚拟机。因此，我们便知道 java 程序，是我们启动jvm的核心开关。

4.0. jvm启动流程框架

废话不多说，java.c, 是我们要研究的重要文件。它将是一个控制启动流程的实现超人。而它的入口，就是在main()中的定义 jli_launch(...) ， 所以让我们一睹真容。

// share/bin/java.c
/*
 * entry point.
 */
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.)
 */
 // 解析命令行参数，选择一jre版本
 selectversion(argc, argv, &main_class);
 createexecutionenvironment(&argc, &argv,
  jrepath, sizeof(jrepath),
  jvmpath, sizeof(jvmpath),
  jvmcfg, sizeof(jvmcfg));
 if (!isjavaargs()) {
 // 设置一些特殊的环境变量
 setjvmenvironment(argc,argv);
 }
 ifn.createjavavm = 0;
 ifn.getdefaultjavavminitargs = 0;
 if (jli_istracelauncher()) {
 start = counterget(); // 记录启动时间
 }
 // 加载vm, 重中之重
 if (!loadjavavm(jvmpath, &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");
 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) {
 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();
 // 初始化jvm，即加载java程序开始，应用表演时间到
 return jvminit(&ifn, threadstacksize, argc, argv, mode, what, ret);
}

以上就是整个jvm虚拟机的启动过程框架了，基本上跑不掉几个点，就是解析命令行参数，设置参数到某范围内或者环境变量中。加载必要模块，传递变量存储。初始化系统。解析用户系统实现。当然一般地，就是会实现系统主循环，这个动作是由使用系统完成的，jvm只负责执行即可。

因为我们只是想了解大概，所以不以为然，只是其中任何一个点都足够研究很久很久了。抛开那些不说，捡个芝麻先。需要明白：懂得许多的道理却依然过不好这一生。只能安心做个吃瓜群众。

下面，就一些细节点，我们可以视兴趣，稍微深入了解下！

4.1. jre版本选择过程

以上框架中，几个重要的节点，我们可以再细化下实现。细节就不说，太复杂。首先，就是如何确定当前系统使用的jre版本，这很重要，它决定了应用系统是否可以运行的问题。因为有时候，系统的使用者并非开发者，一定存在正确的jre版本。没有jre的环境，所有java执行就会是一句空谈。

// java.c
/*
 * the selectversion() routine ensures that an appropriate version of
 * the jre is running. the specification for the appropriate version
 * is obtained from either the manifest of a jar file (preferred) or
 * from command line options.
 * the routine also parses splash screen command line options and
 * passes on their values in private environment variables.
 */
static void
selectversion(int argc, char **argv, char **main_class)
{
 char *arg;
 char **new_argv;
 char **new_argp;
 char *operand;
 char *version = null;
 char *jre = null;
 int jarflag = 0;
 int headlessflag = 0;
 int restrict_search = -1; /* -1 implies not known */
 manifest_info info;
 char env_entry[maxnamelen + 24] = env_entry "=";
 char *splash_file_name = null;
 char *splash_jar_name = null;
 char *env_in;
 int res;
 /*
 * if the version has already been selected, set *main_class
 * with the value passed through the environment (if any) and
 * simply return.
 */
 // _java_version_set=
 if ((env_in = getenv(env_entry)) != null) {
 if (*env_in != '\0')
 *main_class = jli_stringdup(env_in);
 return;
 }
 /*
 * scan through the arguments for options relevant to multiple jre
 * support. for reference, the command line syntax is defined as:
 *
 * synopsis
 * java [options] class [argument...]
 *
 * java [options] -jar file.jar [argument...]
 *
 * as the scan is performed, make a copy of the argument list with
 * the version specification options (new to 1.5) removed, so that
 * a version less than 1.5 can be exec'd.
 *
 * note that due to the syntax of the native windows interface
 * createprocess(), processing similar to the following exists in
 * the windows platform specific routine execjre (in java_md.c).
 * changes here should be reproduced there.
 */
 new_argv = jli_memalloc((argc + 1) * sizeof(char*));
 new_argv[0] = argv[0];
 new_argp = &new_argv[1];
 argc--;
 argv++;
 while ((arg = *argv) != 0 && *arg == '-') {
 if (jli_strccmp(arg, "-version:") == 0) {
 version = arg + 9;
 } else if (jli_strcmp(arg, "-jre-restrict-search") == 0) {
 restrict_search = 1;
 } else if (jli_strcmp(arg, "-no-jre-restrict-search") == 0) {
 restrict_search = 0;
 } else {
 if (jli_strcmp(arg, "-jar") == 0)
 jarflag = 1;
 /* deal with "unfortunate" classpath syntax */
 if ((jli_strcmp(arg, "-classpath") == 0 || jli_strcmp(arg, "-cp") == 0) &&
 (argc >= 2)) {
 *new_argp++ = arg;
 argc--;
 argv++;
 arg = *argv;
 }
 /*
 * checking for headless toolkit option in the some way as awt does:
 * "true" means true and any other value means false
 */
 if (jli_strcmp(arg, "-djava.awt.headless=true") == 0) {
 headlessflag = 1;
 } else if (jli_strccmp(arg, "-djava.awt.headless=") == 0) {
 headlessflag = 0;
 } else if (jli_strccmp(arg, "-splash:") == 0) {
 splash_file_name = arg+8;
 }
 *new_argp++ = arg;
 }
 argc--;
 argv++;
 }
 if (argc <= 0) { /* no operand? possibly legit with -[full]version */
 operand = null;
 } else {
 argc--;
 *new_argp++ = operand = *argv++;
 }
 while (argc-- > 0) /* copy over [argument...] */
 *new_argp++ = *argv++;
 *new_argp = null;
 /*
 * if there is a jar file, read the manifest. if the jarfile can't be
 * read, the manifest can't be read from the jar file, or the manifest
 * is corrupt, issue the appropriate error messages and exit.
 *
 * even if there isn't a jar file, construct a manifest_info structure
 * containing the command line information. it's a convenient way to carry
 * this data around.
 */
 if (jarflag && operand) {
 if ((res = jli_parsemanifest(operand, &info)) != 0) {
 if (res == -1)
 jli_reporterrormessage(jar_error2, operand);
 else
 jli_reporterrormessage(jar_error3, operand);
 exit(1);
 }
 /*
 * command line splash screen option should have precedence
 * over the manifest, so the manifest data is used only if
 * splash_file_name has not been initialized above during command
 * line parsing
 */
 if (!headlessflag && !splash_file_name && info.splashscreen_image_file_name) {
 splash_file_name = info.splashscreen_image_file_name;
 splash_jar_name = operand;
 }
 } else {
 info.manifest_version = null;
 info.main_class = null;
 info.jre_version = null;
 info.jre_restrict_search = 0;
 }
 /*
 * passing on splash screen info in environment variables
 */
 if (splash_file_name && !headlessflag) {
 char* splash_file_entry = jli_memalloc(jli_strlen(splash_file_env_entry "=")+jli_strlen(splash_file_name)+1);
 jli_strcpy(splash_file_entry, splash_file_env_entry "=");
 jli_strcat(splash_file_entry, splash_file_name);
 putenv(splash_file_entry);
 }
 if (splash_jar_name && !headlessflag) {
 char* splash_jar_entry = jli_memalloc(jli_strlen(splash_jar_env_entry "=")+jli_strlen(splash_jar_name)+1);
 jli_strcpy(splash_jar_entry, splash_jar_env_entry "=");
 jli_strcat(splash_jar_entry, splash_jar_name);
 putenv(splash_jar_entry);
 }
 /*
 * the jre-version and jre-restrict-search values (if any) from the
 * manifest are overwritten by any specified on the command line.
 */
 if (version != null)
 info.jre_version = version;
 if (restrict_search != -1)
 info.jre_restrict_search = restrict_search;
 /*
 * "valid" returns (other than unrecoverable errors) follow. set
 * main_class as a side-effect of this routine.
 */
 if (info.main_class != null)
 *main_class = jli_stringdup(info.main_class);
 /*
 * if no version selection information is found either on the command
 * line or in the manifest, simply return.
 */
 if (info.jre_version == null) {
 jli_freemanifest();
 jli_memfree(new_argv);
 return;
 }
 /*
 * check for correct syntax of the version specification (jsr 56).
 */
 if (!jli_validversionstring(info.jre_version)) {
 jli_reporterrormessage(spc_error1, info.jre_version);
 exit(1);
 }
 /*
 * find the appropriate jvm on the system. just to be as forgiving as
 * possible, if the standard algorithms don't locate an appropriate
 * jre, check to see if the one running will satisfy the requirements.
 * this can happen on systems which haven't been set-up for multiple
 * jre support.
 */
 jre = locatejre(&info);
 jli_tracelauncher("jre-version = %s, jre-restrict-search = %s selected = %s\n",
 (info.jre_version?info.jre_version:"null"),
 (info.jre_restrict_search?"true":"false"), (jre?jre:"null"));
 if (jre == null) {
 if (jli_acceptablerelease(getfullversion(), info.jre_version)) {
 jli_freemanifest();
 jli_memfree(new_argv);
 return;
 } else {
 jli_reporterrormessage(cfg_error4, info.jre_version);
 exit(1);
 }
 }
 /*
 * if i'm not the chosen one, exec the chosen one. returning from
 * execjre indicates that i am indeed the chosen one.
 *
 * the private environment variable _java_version_set is used to
 * prevent the chosen one from re-reading the manifest file and
 * using the values found within to override the (potential) command
 * line flags stripped from argv (because the target may not
 * understand them). passing the mainclass value is an optimization
 * to avoid locating, expanding and parsing the manifest extra
 * times.
 */
 if (info.main_class != null) {
 if (jli_strlen(info.main_class) <= maxnamelen) {
 (void)jli_strcat(env_entry, info.main_class);
 } else {
 jli_reporterrormessage(cls_error5, maxnamelen);
 exit(1);
 }
 }
 (void)putenv(env_entry);
 execjre(jre, new_argv);
 jli_freemanifest();
 jli_memfree(new_argv);
 return;
}

逻辑也不复杂，大概就是，解析参数，读取manifest文件，jre版本校验，加载jre以便确认是否存在，最后将相关环境变量放置好。

4.2. 加载vm模块

加载vm是非常重要的一个工作。它是一个平台相关的实现，我们看下 windows版本的实现吧。

// share/windows/bin/java_md.c
/*
 * load a jvm from "jvmpath" and initialize the invocation functions.
 */
jboolean
loadjavavm(const char *jvmpath, invocationfunctions *ifn)
{
 hinstance handle;
 jli_tracelauncher("jvm path is %s\n", jvmpath);
 /*
 * the microsoft c runtime library needs to be loaded first. a copy is
 * assumed to be present in the "jre path" directory. if it is not found
 * there (or "jre path" fails to resolve), skip the explicit load and let
 * nature take its course, which is likely to be a failure to execute.
 *
 */
 loadmsvcrt();
 // windows 中是通过路径加载dll文件实现
 /* load the java vm dll */
 if ((handle = loadlibrary(jvmpath)) == 0) {
 jli_reporterrormessage(dll_error4, (char *)jvmpath);
 return jni_false;
 }
 /* now get the function addresses */
 // 获取虚拟机操作内存地址
 ifn->createjavavm =
 (void *)getprocaddress(handle, "jni_createjavavm");
 ifn->getdefaultjavavminitargs =
 (void *)getprocaddress(handle, "jni_getdefaultjavavminitargs");
 if (ifn->createjavavm == 0 || ifn->getdefaultjavavminitargs == 0) {
 jli_reporterrormessage(jni_error1, (char *)jvmpath);
 return jni_false;
 }
 return jni_true;
}

可见，最重要的工作是被封装到 jre 中的，应用层面只是调用jre的方法即可。在windows中通过加载msvcrt模块完成工作，然后抽取vm的两个方法签名到ifn中，以便后续实用。

4.3. 解析参数信息

通过参数解析，我们就可以如何设置参数了。更深层次的理解。

// 实际就是语法规范
/*
 * parses command line arguments. returns jni_false if launcher
 * should exit without starting vm, returns jni_true if vm needs
 * to be started to process given options. *pret (the launcher
 * process return value) is set to 0 for a normal exit.
 */
static jboolean
parsearguments(int *pargc, char ***pargv,
 int *pmode, char **pwhat,
 int *pret, const char *jrepath)
{
 int argc = *pargc;
 char **argv = *pargv;
 int mode = lm_unknown;
 char *arg;
 *pret = 0;
 while ((arg = *argv) != 0 && *arg == '-') {
 argv++; --argc;
 if (jli_strcmp(arg, "-classpath") == 0 || jli_strcmp(arg, "-cp") == 0) {
 arg_check (argc, arg_error1, arg);
 setclasspath(*argv);
 mode = lm_class;
 argv++; --argc;
 } else if (jli_strcmp(arg, "-jar") == 0) {
 arg_check (argc, arg_error2, arg);
 mode = lm_jar;
 } else if (jli_strcmp(arg, "-help") == 0 ||
  jli_strcmp(arg, "-h") == 0 ||
  jli_strcmp(arg, "-?") == 0) {
 printusage = jni_true;
 return jni_true;
 } else if (jli_strcmp(arg, "-version") == 0) {
 printversion = jni_true;
 return jni_true;
 } else if (jli_strcmp(arg, "-showversion") == 0) {
 showversion = jni_true;
 } else if (jli_strcmp(arg, "-x") == 0) {
 printxusage = jni_true;
 return jni_true;
/*
 * the following case checks for -xshowsettings or -xshowsetting:subopt.
 * in the latter case, any subopt value not recognized will default to "all"
 */
 } else if (jli_strcmp(arg, "-xshowsettings") == 0 ||
 jli_strccmp(arg, "-xshowsettings:") == 0) {
 showsettings = arg;
 } else if (jli_strcmp(arg, "-xdiag") == 0) {
 addoption("-dsun.java.launcher.diag=true", null);
/*
 * the following case provide backward compatibility with old-style
 * command line options.
 */
 } else if (jli_strcmp(arg, "-fullversion") == 0) {
 jli_reportmessage("%s full version \"%s\"", _launcher_name, getfullversion());
 return jni_false;
 } else if (jli_strcmp(arg, "-verbosegc") == 0) {
 addoption("-verbose:gc", null);
 } else if (jli_strcmp(arg, "-t") == 0) {
 addoption("-xt", null);
 } else if (jli_strcmp(arg, "-tm") == 0) {
 addoption("-xtm", null);
 } else if (jli_strcmp(arg, "-debug") == 0) {
 addoption("-xdebug", null);
 } else if (jli_strcmp(arg, "-noclassgc") == 0) {
 addoption("-xnoclassgc", null);
 } else if (jli_strcmp(arg, "-xfuture") == 0) {
 addoption("-xverify:all", null);
 } else if (jli_strcmp(arg, "-verify") == 0) {
 addoption("-xverify:all", null);
 } else if (jli_strcmp(arg, "-verifyremote") == 0) {
 addoption("-xverify:remote", null);
 } else if (jli_strcmp(arg, "-noverify") == 0) {
 addoption("-xverify:none", null);
 } else if (jli_strccmp(arg, "-prof") == 0) {
 char *p = arg + 5;
 char *tmp = jli_memalloc(jli_strlen(arg) + 50);
 if (*p) {
 sprintf(tmp, "-xrunhprof:cpu=old,file=%s", p + 1);
 } else {
 sprintf(tmp, "-xrunhprof:cpu=old,file=java.prof");
 }
 addoption(tmp, null);
 } else 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);
 } else if (jli_strcmp(arg, "-checksource") == 0 ||
  jli_strcmp(arg, "-cs") == 0 ||
  jli_strcmp(arg, "-noasyncgc") == 0) {
 /* no longer supported */
 jli_reporterrormessage(arg_warn, arg);
 } else if (jli_strccmp(arg, "-version:") == 0 ||
  jli_strcmp(arg, "-no-jre-restrict-search") == 0 ||
  jli_strcmp(arg, "-jre-restrict-search") == 0 ||
  jli_strccmp(arg, "-splash:") == 0) {
 ; /* ignore machine independent options already handled */
 } else if (processplatformoption(arg)) {
 ; /* processing of platform dependent options */
 } else if (removableoption(arg)) {
 ; /* do not pass option to vm. */
 } else {
 addoption(arg, null);
 }
 }
 if (--argc >= 0) {
 *pwhat = *argv++;
 }
 if (*pwhat == null) {
 *pret = 1;
 } else if (mode == lm_unknown) {
 /* default to lm_class if -jar and -cp option are
 * not specified */
 mode = lm_class;
 }
 if (argc >= 0) {
 *pargc = argc;
 *pargv = argv;
 }
 *pmode = mode;
 return jni_true;
}
/*
 * inject the -dsun.java.command pseudo property into the args structure
 * this pseudo property is used in the hotspot vm to expose the
 * java class name and arguments to the main method to the vm. the
 * hotspot vm uses this pseudo property to store the java class name
 * (or jar file name) and the arguments to the class's main method
 * to the instrumentation memory region. the sun.java.command pseudo
 * property is not exported by hotspot to the java layer.
 */
void
setjavacommandlineprop(char *what, int argc, char **argv)
{
 int i = 0;
 size_t len = 0;
 char* javacommand = null;
 char* dashdstr = "-dsun.java.command=";
 if (what == null) {
 /* unexpected, one of these should be set. just return without
 * setting the property
 */
 return;
 }
 /* determine the amount of memory to allocate assuming
 * the individual components will be space separated
 */
 len = jli_strlen(what);
 for (i = 0; i < argc; i++) {
 len += jli_strlen(argv[i]) + 1;
 }
 /* allocate the memory */
 javacommand = (char*) jli_memalloc(len + jli_strlen(dashdstr) + 1);
 /* build the -d string */
 *javacommand = '\0';
 jli_strcat(javacommand, dashdstr);
 jli_strcat(javacommand, what);
 for (i = 0; i < argc; i++) {
 /* the components of the string are space separated. in
 * the case of embedded white space, the relationship of
 * the white space separated components to their true
 * positional arguments will be ambiguous. this issue may
 * be addressed in a future release.
 */
 jli_strcat(javacommand, " ");
 jli_strcat(javacommand, argv[i]);
 }
 addoption(javacommand, null);
}

// 设置 classpath
static void
setclasspath(const char *s)
{
 char *def;
 const char *orig = s;
 static const char format[] = "-djava.class.path=%s";
 /*
 * usually we should not get a null pointer, but there are cases where
 * we might just get one, in which case we simply ignore it, and let the
 * caller deal with it
 */
 if (s == null)
 return;
 s = jli_wildcardexpandclasspath(s);
 if (sizeof(format) - 2 + jli_strlen(s) < jli_strlen(s))
 // s is corrupted after wildcard expansion
 return;
 def = jli_memalloc(sizeof(format)
  - 2 /* strlen("%s") */
  + jli_strlen(s));
 sprintf(def, format, s);
 addoption(def, null);
 if (s != orig)
 jli_memfree((char *) s);
}

-xxxxx, --xxx格式配置，如 -xms1024g, --noclassgc ... 然后解析出来。最后通过addoption()存储起来。

4.4. jvm初始化

好像我们一直讨论的都是这个，但是实际上里面还有一个真正的jvm的初始化过程。这里方才会接入真正的java程序，也才大家所关心的地方。

// java.c
jvminit(invocationfunctions* ifn, jlong threadstacksize,
 int argc, char **argv,
 int mode, char *what, int ret)
{
 showsplashscreen();
 return continueinnewthread(ifn, threadstacksize, argc, argv, mode, what, ret);
}

/*
 * displays the splash screen according to the jar file name
 * and image file names stored in environment variables
 */
void
showsplashscreen()
{
 const char *jar_name = getenv(splash_jar_env_entry);
 const char *file_name = getenv(splash_file_env_entry);
 int data_size;
 void *image_data = null;
 float scale_factor = 1;
 char *scaled_splash_name = null;
 if (file_name == null){
 return;
 }
 scaled_splash_name = dosplashgetscaledimagename(
  jar_name, file_name, &scale_factor);
 if (jar_name) {
 if (scaled_splash_name) {
 image_data = jli_jarunpackfile(
  jar_name, scaled_splash_name, &data_size);
 }
 if (!image_data) {
 scale_factor = 1;
 image_data = jli_jarunpackfile(
  jar_name, file_name, &data_size);
 }
 if (image_data) {
 dosplashinit();
 dosplashsetscalefactor(scale_factor);
 dosplashloadmemory(image_data, data_size);
 jli_memfree(image_data);
 }
 } else {
 dosplashinit();
 if (scaled_splash_name) {
 dosplashsetscalefactor(scale_factor);
 dosplashloadfile(scaled_splash_name);
 } else {
 dosplashloadfile(file_name);
 }
 }
 if (scaled_splash_name) {
 jli_memfree(scaled_splash_name);
 }
 dosplashsetfilejarname(file_name, jar_name);
 /*
 * done with all command line processing and potential re-execs so
 * clean up the environment.
 */
 (void)unsetenv(env_entry);
 (void)unsetenv(splash_file_env_entry);
 (void)unsetenv(splash_jar_env_entry);
 jli_memfree(splash_jar_entry);
 jli_memfree(splash_file_entry);
}


int
continueinnewthread(invocationfunctions* ifn, jlong threadstacksize,
  int argc, char **argv,
  int mode, char *what, int ret)
{
 /*
 * if user doesn't specify stack size, check if vm has a preference.
 * note that hotspot no longer supports jni_version_1_1 but it will
 * return its default stack size through the init args structure.
 */
 if (threadstacksize == 0) {
 struct jdk1_1initargs args1_1;
 memset((void*)&args1_1, 0, sizeof(args1_1));
 args1_1.version = jni_version_1_1;
 ifn->getdefaultjavavminitargs(&args1_1); /* ignore return value */
 if (args1_1.javastacksize > 0) {
 threadstacksize = args1_1.javastacksize;
 }
 }
 { /* create a new thread to create jvm and invoke main method */
 javamainargs args;
 int rslt;
 args.argc = argc;
 args.argv = argv;
 args.mode = mode;
 args.what = what;
 args.ifn = *ifn;
 rslt = continueinnewthread0(javamain, threadstacksize, (void*)&args);
 /* if the caller has deemed there is an error we
 * simply return that, otherwise we return the value of
 * the callee
 */
 return (ret != 0) ? ret : rslt;
 }
}

看起来，jvm是通过一个新线程去运行应用系统的。在将执行控制权交由java代码后，它的主要作用，就是不停地接收命令，执行命令。从而变成一个真正的执行机器。

到此这篇关于深入理解java之jvm启动流程的文章就介绍到这了,更多相关java之jvm启动流程内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！