Learn JVM
1. JVM 基础
1.1 Java从编码到执行
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eQguryO5-1634915025194)(https://files.mdnice.com/user/20547/c67ccb8e-5c16-414a-a11b-7ca574cf896a.png)]
Java-跨平台的语言：一处编译，可以在运行JVM的任何平台运行
JVM-跨语言的平台：无论什么语言，只要按照JVM的规范编译成符合Class文件的规范的文件，既可以在JVM上运行
1.2 JAVA&JVM文档
查看Java语言和JVM规范，可以查看官方的文档，访问官网查看需要的版本即可
Java SE Specifications (oracle.com)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XA0zwdSZ-1634915025197)(D:\OneDrive\桌面备份\typora-user-images\1633328816693.png)]
1.3常见的JVM的实现
我们使用的JVM可以控制台查看：
2. CLASS文件解读
2.1 如何将java源码生成.class文件
使用命令行，我们可以使用javac指令将编辑好的java文件编译成.class文件，当然也可以使用IDE工具进行编译生成.class文件
但是我们使用IDE工具打开的.class文件，工具会帮我们反编译，所以要查看原格式文件需要借助插件，这里我们使用BinED
装好之后右击.class文件，选择 Open As Binary即可以16进制，二进制，或者八进制，十进制查看
下面我们以16进制查看.class文件然后分析，下图是我们上面简单的代码编译后生成的.class文件的字节码code
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jmSShiSp-1634915025202)(D:\OneDrive\桌面备份\typora-user-images\1633355532799.png)]
后面为了方便我们更好的阅读class文件，选择另一个IDEA的插件：jclasslib
鼠标放在要查看class源码文件内部，在工具栏View中选择Show Bytecode With Jclasslib，打开之后如下图所示，方便查看里面的内容
2.2 CLASS文件的格式
这里实验使用的是JDK1.8版本，查看JAVA官网提供的手册
https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf
第四章可以看到其中对于ClassFile结构的定义，源文件描述如下:
注: u4 表示4个字节，对应到.class文件可以确认前面的4个字节"CA FE BA BE"是这所谓的magic
2.2.1 magic
0x CAFE BABE
然后再往下看这个class文件
2.2.2 minor_version&major_version
minor_version: 0x0000
major_version: 0x0034
对应的10进制的值为52，然后我们查看文档中major versions format 可以看出对应的为java 8
2.2.3 constant_pool_count
0x0010 = 16
常量池数量
2.2.4 constant_pool[]
2.2.5 常量池的类型
下面开始分析class文件常量池部分
0x0A 对应十进制的10，查表可以看出tag 10为Constant_methodref
3. Class加载器ClassLoader
一个类，编译后生成class文件在硬盘上，需要先将class文件加载到内存，加载过程包括以下几步：
1. Loading
2. Linking:
? Verification
? Preparation，class静态变量赋值默认值
? Resolution，静态变量赋值，初始化
这里先来看Loading过程
3.1 类加载器
3.1.1 双亲委派加载机制
所谓的父加载器，并不是加载器的父类加载器，也不是类加载器的加载器，只是类加载时的关系
为什么要有双亲委派这种类加载机制？主要是为了安全（核心类库中的类，防止自定义然后加载），以及效率（已经加载过的类不被重复加载），
所谓的双亲委派：
加载一个类时，先去查看是否已经加载，如果没有加载过，则让父加载器查看是否已加载，逐级向上，到顶级父加载器时也都没加载过则从上向下逐级尝试进行加载，知道加载完成，如果没有最终没有完成加载抛出异常
类加载的源代码如下：
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
3.1.2 类加载器的范围
3.1.3 自定义类加载器
继承ClassLoader类，重写loadClass(String name) 方法
示例：
package cn.qiyuandata.classloader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
/**
* Title:MyClassLoader01
* <p>
* Desc:
* <p>
* At 2021/10/10
*
* @author ZhaoJu
*/
public class MyClassLoader01 extends ClassLoader{
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
File f = new File("G:/document/code/Java/LearnJvm/out/production/LearnJvm/", name.replace(".", "/").concat(".class"));
try {
FileInputStream fis = new FileInputStream(f);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
int b = 0;
while ((b=fis.read()) !=0) {
byteArrayOutputStream.write(b);
}
byte[] bytes = byteArrayOutputStream.toByteArray();
byteArrayOutputStream.close();
fis.close();//可以写的更加严谨
return defineClass(name, bytes, 0, bytes.length);
} catch (Exception e) {
e.printStackTrace();
}
//throws ClassNotFoundException
return super.findClass(name);
}
}
使用举例：
热部署，一个类完成编辑编译后需要自动把新的class加载进内存实现替换，需要定义加载器
4. 编译
默认为混合模式，可以在启动参数设置编译模式，可以选择解释模式，或纯编译模式，对应如下
5. 初始化
静态变量赋默认值
静态变量赋初始值
看下面一段代码，Test类里有静态变量a，初始值为2，那下面一段代码的
package cn.qiyuandata.jvm;
public class InitTest01 {
public static void main(String[] args) {
System.out.println(Test.a);
}
}
class Test{
public static Test test = new Test();
public static int a =2;
private Test(){
a++;
}
}
这段代码输出的结果是几？答案是2
为什么呢，因为Test这个类在被调用时，先加载进来，然后声明test变量内存，这时test为null，a为默认值0
接下来调用构造方法a++，得到a=1
然后在执行a赋初始值a=2
所以最终结果为a=2
那么再来看下面一段代码呢，a与test的声明换了下位置，结果是几呢？
package cn.qiyuandata.jvm;
public class InitTest01 {
public static void main(String[] args) {
System.out.println(Test.a);
}
}
class Test{
public static int a =2;
public static Test test = new Test();
private Test(){
a++;
}
}
结果是3，为什么呢？
因为加载class后a赋默认值0，然后初始化为2
然后test声明为null
再然后执行构造方法，a++，值变成了3
以上是关于静态变量，接下来在讨论下关于成员变量的初始化
成员变量在new对象时进行初始化
初始化也是分为两步，先分配空间，声明变量，赋默认值，然后再赋初始值