JVM 1.3 JVM 启动流程
JVM是Java程序运行的环境,但是他同时一个操作系统的一个应用程序一个进程,因此他也有他自己的运行的生命周期,也有自己的代码和数据空间。
JVM工作原理和特点主要是指操作系统装入JVM是通过JDK中java.exe来完成,通过下面5步来完成JVM环境.
1.步骤1：JVM装入环境
JVM提供的方式是操作系统的动态链接库文件（dll文件）
1）JVM路径的确定
Java是通过GetApplicationHomeAPI来获得当前的Java.exe绝对路径：
该方法实现如下：
/*
* 如果一个应用服务的执行路径是："c:\foo\bin\javac", 那么就会缓存"c:\foo"目录
*/
jboolean
GetApplicationHome(char *buf, jint bufsize)// buf 相当于 "c:\foo\bin\javac"
{
char *cp;
GetModuleFileName(0, buf, bufsize);
*JLI_StrRChr(buf, '\\') = '\0'; /* 移除路径中的.exe文件名*/
if ((cp = JLI_StrRChr(buf, '\\')) == 0) {
/* 当应用使用的是根目录而不包含bin\ 目录. */
buf[0] = '\0';
return JNI_FALSE;
}
*cp = '\0'; /* 移除目录中的 bin\ 部分 */
return JNI_TRUE;
}
再看看其调用者：
/*
* 根据当前任性的exe命令文件位置或者注册设置来找到JRE的根目录位置*/
jboolean
GetJREPath(char *path, jint pathsize){
char javadll[MAXPATHLEN];
struct stat s;
if (GetApplicationHome(path, pathsize)) {
/* Is JRE co-located with the application? */
JLI_Snprintf(javadll, sizeof(javadll), "%s\\bin\\" JAVA_DLL, path);
if (stat(javadll, &s) == 0) {
JLI_TraceLauncher("JRE path is %s\n", path);
return JNI_TRUE;
}
/* 确保存储路径 + \jre + NULL */
if ((JLI_StrLen(path) + 4 + 1) > pathsize) {
JLI_TraceLauncher("Insufficient space to store JRE path\n");
return JNI_FALSE;
}
/* 此应用程序是否在 应用程序家目录（$JAVA_HOME）下有jre目录 */
JLI_Snprintf(javadll, sizeof (javadll), "%s\\jre\\bin\\" JAVA_DLL, path);
if (stat(javadll, &s) == 0) {
JLI_StrCat(path, "\\jre"); //如果有jre目录，那么将把$JAVA_HOME/jre作为jre根目录
JLI_TraceLauncher("JRE path is %s\n", path);
return JNI_TRUE;
}
}
显然，如果我的指令命令java.exe所在路径是C:\jdk8\bin\java.exe，那么那会去掉bin\java.exe,然后进行各项判断，最终找到C:\jdk8\bin\jre作为JRE的家目录。如果没有找到的话，最终会调用GetPublicJREHome API 到你的注册表中HKEY_LOCAL_MACHINE\Software\JavaSoft\Java Runtime Environment\当前版本号\JAVA_HOME去找的。
2）装载jvm.cfg文件
然后装载JVM.cfg文件：JRE路径\lib\ARCH（CPU构架）\JVM.cfg ：
关于ARCH（CPU构架）的判断则是通过如下方法得到的：
/*
* Returns the arch path, to get the current arch use the
* macro GetArch, nbits here is ignored for now.
*/
const char *
GetArchPath(int nbits)
{
#ifdef _M_AMD64 // 貌似无论是AMDCPU还是现在普遍使用的英特尔处理器都是这个目录
return "amd64";
#elif defined(_M_IA64) // 英特尔安腾64位处理器
return "ia64";
#else
return "i386"; //32位处理器
#endif
}
例如我的电脑是Intel Core 8870U 64位的,那么目录是amd64,也因此我的jvm.cfg文件的路径是：
C:\jdk8\jre\lib\amd64\jvm.cfg,其内容如下：
-server KNOWN # 默认第一选项即server类型 VM
-client IGNORE # IGNORE即忽略该模式，使用默认模式
值得注意的是，好像在后续的版本中，默认使用的都是server类型的vm了，甚至连之前默认的client版本的vm都不再支持了。
一般来说，默认的java.dll文件存储位置是在KaTeX parse error: Expected 'EOF', got '\jdk' at position 27: …n/VM类型,例如我的：`C:\̲j̲d̲k̲8\jre\bin\serve…JRE_HOME/bin下面并没有类似client等字眼，即不支持client vm了。
要知道，官方之所以选择server vm,而放弃client vm主要还是因为client vm是轻量级的，启动时速度比较快，但是稳定后，其执行速度远不及server vm，而sever vm虽然是重量级的，但是其内部的优化做的比较好，所以一旦稳定下来，server vm可以吊打 client vm。
2.装载jvm.dll文件
通过第一步已经找到了JVM的路径，Java通过LoadJavaVM来装入JVM.dll文件．装入工作很简单就是调用Windows API函数：
/*
* 从JRE路径中加载一个jvm，并初始化调用函数
*/
jboolean
LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)
{
HINSTANCE handle;
JLI_TraceLauncher("JVM path is %s\n", jvmpath);
/*
* 首选需要加载C运行时库，副本是假定存在于“jre path”目录中。如果找不到这里（或者“jre路径”解析失 * 败），跳过显式加载并按照默认处理方式进行处理，这很可能是执行失败。
*/
LoadMSVCRT();
/* 加载jvm.dll动态链接库文件 */
if ((handle = LoadLibrary(jvmpath)) == 0) {
JLI_ReportErrorMessage(DLL_ERROR4, (char *)jvmpath);
return JNI_FALSE;
}
/* 现在获取这个函数的地址信息 */
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;
}
LoadLibrary装载JVM.dll动态连接库．然后把JVM.dll中的导出函数JNI_CreateJavaVM和JNI_GetDefaultJavaVMInitArgs挂接到InvocationFunctions变量的CreateJavaVM和GetDefaultJavaVMInitArgs函数指针变量上。JVM.dll的装载工作宣告完成。
3.初始化JVM
获得本地调用接口，这样就可以在Java中调用JVM的函数了．调用InvocationFunctions－>CreateJavaVM也就是JVM中JNI_CreateJavaVM方法获得JNIEnv结构的实例．
4.运行程序
Java程序有两种方式:
一种是jar包
一种是class. 运行jar
Java -jar XXX.jar运行的时候，Java.exe调用GetApplicationClass函数，该函数先获得JNIEnv实例然后调用Java类Java.util.jar.JarFileJNIEnv中方法getManifest()并从返回的Manifest对象中取getAttributes(“Main-Class”)的值即jar包中文件：META-INF/MANIFEST.MF指定的Main-Class的主类名作为运行的主类。之后main函数会调用Java.c中LoadMainClass方法装载该主类（使用JNIEnv实例的FindClass）。main函数直接调用Java.c中LoadMainClass方法装载该类。
1）应用程序的主类的获取
static jclass
GetApplicationClass(JNIEnv *env)
{
jmethodID mid;
jobject result;
jclass cls = GetLauncherHelperClass(env);
NULL_CHECK0(cls);
NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls,
"getApplicationClass",
"()Ljava/lang/Class;"));
return (*env)->CallStaticObjectMethod(env, cls, mid);
}
2）应用程序主类main方法的参数的获取：
/*
* For tools, convert command line args thus:
* javac -cp foo:foo/"*" -J-ms32m ...
* java -ms32m -cp JLI_WildcardExpandClasspath(foo:foo/"*") ...
*
* Takes 4 parameters, and returns the populated arguments
*/
static void
TranslateApplicationArgs(int jargc, const char **jargv, int *pargc, char ***pargv)
{
int argc = *pargc;
char **argv = *pargv;
int nargc = argc + jargc;
char **nargv = JLI_MemAlloc((nargc + 1) * sizeof(char *));
int i;
*pargc = nargc;
*pargv = nargv;
/* Copy the VM arguments (i.e. prefixed with -J) */
for (i = 0; i < jargc; i++) {
const char *arg = jargv[i];
if (arg[0] == '-' && arg[1] == 'J') {
*nargv++ = ((arg + 2) == NULL) ? NULL : JLI_StringDup(arg + 2);
}
}
for (i = 0; i < argc; i++) {
char *arg = argv[i];
if (arg[0] == '-' && arg[1] == 'J') {
if (arg[2] == '\0') {
JLI_ReportErrorMessage(ARG_ERROR3);
exit(1);
}
*nargv++ = arg + 2;
}
}
/* Copy the rest of the arguments */
for (i = 0; i < jargc ; i++) {
const char *arg = jargv[i];
if (arg[0] != '-' || arg[1] != 'J') {
*nargv++ = (arg == NULL) ? NULL : JLI_StringDup(arg);
}
}
for (i = 0; i < argc; i++) {
char *arg = argv[i];
if (arg[0] == '-') {
if (arg[1] == 'J')
continue;
if (IsWildCardEnabled() && arg[1] == 'c'
&& (JLI_StrCmp(arg, "-cp") == 0 ||
JLI_StrCmp(arg, "-classpath") == 0)
&& i < argc - 1) {
*nargv++ = arg;
*nargv++ = (char *) JLI_WildcardExpandClasspath(argv[i+1]);
i++;
continue;
}
}
*nargv++ = arg;
}
*nargv = 0;
}
3）加载主类：
/*
* Loads a class and verifies that the main class is present and it is ok to
* call it for more details refer to the java implementation.
*/
static jclass
LoadMainClass(JNIEnv *env, int mode, char *name)
{
jmethodID mid;
jstring str;
jobject result;
jlong start, end;
jclass cls = GetLauncherHelperClass(env);
NULL_CHECK0(cls);
if (JLI_IsTraceLauncher()) {
start = CounterGet();
}
NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls,
"checkAndLoadMain",
"(ZILjava/lang/String;)Ljava/lang/Class;"));
str = NewPlatformString(env, name);
CHECK_JNI_RETURN_0(
result = (*env)->CallStaticObjectMethod(
env, cls, mid, USE_STDERR, mode, str));
if (JLI_IsTraceLauncher()) {
end = CounterGet();
printf("%ld micro seconds to load main class\n",
(long)(jint)Counter2Micros(end-start));
printf("----%s----\n", JLDEBUG_ENV_ENTRY);
}
return (jclass)result;
}
如果是执行class方法。main函数直接调用Java.c中LoadMainClass方法装载该类。然后main函数调用JNIEnv实例的GetStaticMethodID方法查找装载的class主类中“public static void main(String[] args)”方法，并判断该方法是否为public方法，然后调用JNIEnv实例的CallStaticVoidMethod方法调用该Java类的main方法。