---

前言

本篇主要介绍Java虚拟机——JVM的相关内容。

“基础知识”是本专栏的第一个部分，本篇博文是第四篇博文，如有需要，可：

1. 点击这里，返回本专栏的索引文章
2. 点击这里，返回上一篇《【Java校招面试】基础知识（三）——多线程与并发》

---

一、基础概念

01. Java代码的Compile once, run anywhere是怎么实现的？
所谓Compile once, run anywhere即一次编译，随处运行。

Java源码首先被编译成字节码，再由不同平台的JVM进行解析，Java语言在不同的平台上运行时不需要进行重新编译，Java虚拟机在执行字节码的时候，把字节码转换成具体平台上的机器指令。

02. 为什么不直接将源码解析成机器码去执行？
1) 准备工作: 每次执行前都需要各种检查，降低执行效率；
2) 兼容性: 可以将别的语言编译成字节码，然后用JVM执行，提高兼容性。

03. JVM如何加载.class文件？

JVM主要由Class Loader、Runtime Data Area、Execution Engine和Native Interface组成。

• Class Loader: 依据特定格式，加载class文件到内存
• Execution Engine: 对命令进行解析
• Native Interface: 融合不同开发语言的原生库为Java所用
• Runtime Data Area: JVM内存空间结构模型

---

二、反射

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性。

01. 反射的代码示例
1) 目标类（包含一个私有属性、一个私有方法、一个公有方法，注意包名）

	package reflecttest;
	
	public class Target {
		// 目标类私有属性
	    private String privateField;
	    // 目标类公有方法
	    public void publicMethod(String param) {
	        System.out.println("I'm the public method of Target class.The param is " + param);
	    }
	    // 目标类私有方法
	    private void privateMethod(String param) {
	        System.out.println("I'm the private method of Target class.The param is " + param);
	    }
	}

2) 反射调用类

	public class ReflectTest {
	    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
	        Class targetClass = Class.forName("reflecttest.Target");
	        Target target = (Target) targetClass.newInstance();
	        // 通过反射引用目标类私有属性
	        testPrivateField(targetClass, target);
	        // 通过反射调用目标类公有方法
	        testPublicMethod(targetClass, target);
	        // 通过反射调用目标类私有方法
	        testPrivateMethod(targetClass, target);
	    }
	
	    private static void testPrivateField(Class clazz, Target target) throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
	        Field privateField = clazz.getDeclaredField("privateField");
	        privateField.setAccessible(true);
	        System.out.println("The Origin Value of Private Field Is: " + privateField.get(target));
	        privateField.set(target, "New Value");
	        System.out.println("The Fixed Value of Private Field Is: " + privateField.get(target));
	    }
	
	    private static void testPublicMethod(Class clazz, Target target) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
	        Method publicMethod = clazz.getMethod("publicMethod", String.class);
	        publicMethod.invoke(target, "\"Calling Public Method.\"");
	    }
	
	    private static void testPrivateMethod(Class clazz, Target target) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
	        Method privateMethod = clazz.getDeclaredMethod("privateMethod", String.class);
	        privateMethod.setAccessible(true);
	        privateMethod.invoke(target, "\"Calling Private Method.\"");
	    }
	}

3) 输出结果

The Origin Value of Private Field Is: null
The Fixed Value of Private Field Is: New Value
I'm the public method of Target class. The param is "Calling Public Method."
I'm the private method of Target class. The param is "Calling Private Method."

4) 总结
  ① 流程: 先通过完全限定类名获得类对象，然后newInstance获取实例，该实例用于方法的invoke和属性的set等各种操作；
  ② getDeclaredMethod可以获得类的所有方法，但不能获取继承的和实现的接口函数，getMethod只可以获取public方法，但也可以获取继承的public方法和实现的接口中的方法。对于Field同理；
  ③ 对私有的属性或者方法进行操作时，需要setAccessable(true)，改变访问权限。

---

三、类加载器ClassLoader

ClassLoader的主要工作在Class装载的加载阶段，其主要作用是从系统外部获得Class二进制数据流并装载进系统，然后交给JVM进行连接、初始化等操作。

01. 类从编译到执行的过程
1) 编译器将Test.java源文件编译成Test.class字节码文件；
2) ClassLoader将字节码转换为JVM中的Class对象；
3) JVM利用Class对象实例化Test对象。

02. ClassLoader的类型
1) BootstrapClassLoader: 启动类加载器
  ① 使用C++编写；
  ② 负责加载Java核心库，如java.lang;
  ③ 无法直接获取；
2) ExtClassLoader: 扩展类加载器
  ① 使用Java编写；
  ② 负责加载jdk_home/lib/ext目录下的jar
3) AppClassLoader: 应用类加载器
  ① 使用Java编写；
  ② 负责加载程序所在目录。
4) 自定义ClassLoader

03. 自定义ClassLoader的例子
1) 要加载的目标类：

	public class Target {
	    static {
	        System.out.println("I'm Static Block of Target Class.");
	    }
	}

2) 自定义ClassLoader：

	public class MyClassLoader extends ClassLoader {
	    private String classPath;
	    public MyClassLoader(String classPath) {
	        this.classPath = classPath;
	    }
	
	    @Override
	    protected Class<?> findClass(String name) throws ClassNotFoundException {
	        byte[] clazz = loadClassFromFile(name);
	        return defineClass(name, clazz, 0, clazz.length);
	    }
	
	    public byte[] loadClassFromFile(String className) {
	        String path = classPath + File.separator + className + ".class";
	        try (InputStream in = new FileInputStream(new File(path));
	              ByteArrayOutputStream out = new ByteArrayOutputStream();) {
	            int c;
	            while ((c = in.read())!= -1)
	                out.write(c);
	            return out.toByteArray();
	        } catch (Exception ex) {
	            return null;
	        }
	    }
	}

3) ClassLoader调用类

	public class ClassLoaderTest {
	    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
	        String classPath = "/path/to/class/loader";
	        MyClassLoader classLoader = new MyClassLoader(classPath);
	        Class c = classLoader.loadClass("Target");
	        c.newInstance();
	    }
	}

4) 输出结果

	I'm Static Block of Target Class.

04. ClassLoader双亲委派机制
1) AppClassLoader的父类是ExtClassLoader，ExtClassLoader的父类是BootstrapClassLoader；
2) loadClass方法源码：

		protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
	        // First, check if the class has already been loaded
	        Class c = findLoadedClass(name);
	        if (c == null) {
	            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.
	                c = findClass(name);
	            }
	        }
	        if (resolve) {
	            resolveClass(c);
	        }
	        return c;
	    }

3) 程序逻辑——双亲委派机制

• 首先找缓存（findLoadedClass），没有的话就判断有没有parent，有的话就用parent来递归的loadClass，然而ExtClassLoader并没有设置parent，则会通过findBootstrapClassOrNull来加载class，而findBootstrapClassOrNull则会通过JNI方法private native Class findBootstrapClass(String name)来使用BootStrapClassLoader来加载class。
• 然后如果parent未找到class，则会调用findClass来加载class，findClass是一个protected的空方法，可以覆盖它以便自定义class加载过程。

05. 使用双亲委派机制为什么是安全的？
举个例子，ClassLoader加载的class文件来源很多，比如编译器编译生成的class、或者网络下载的字节码。而一些来源的class文件是不可靠的，比如我可以自定义一个java.lang.Integer类来覆盖jdk中默认的Integer类，例如下面这样：

	package java.lang;
	
	public class Integer {
	    public Integer(int value) {
	        System.exit(0);
	    }
	}

初始化这个Integer的构造器是会退出JVM，破坏应用程序的正常进行。 如果使用双亲委派机制的话，该Integer类永远不会被调用。因为委托BootStrapClassLoader加载后会加载JDK中的Integer类而不会加载自定义的这个，因此就保证了安全性。

06. 类的加载方式
1) 隐式加载: new，程序在运行过程中，遇到需要用new生成对象时，隐式调用类加载器将对应的类加载到JVM中。
2) 显式加载: loadClass，forName等

区别：
1) 显式加载需要先获取类对象，然后调用其newInstance方法获取对象，而隐式加载不需要；
2) new支持调用目标类带参数的构造方法，而newInstance方法则不支持传入参数。

07. 类的装载过程

1) 加载: 通过ClassLoader加载class文件字节码，生成Class对象；
2) 链接:
  ① 校验: 检查加载的类的正确性和安全性；
  ② 准备: 为类变量分配存储空间并设置类变量初始值；
  ③ 解析: JVM将常量池中的符号引用转换为直接引用。
3) 初始化: 执行类变量赋值和静态代码块

08. loadClass和forName的区别
1) Class.forName得到的class是已经初始化完成的；
2) ClassLoader.loadClass得到的class是还没有链接的。

应用场景：
1) 有的类有静态代码块（如mysql-connector），因此需要使用Class.forName；
2) Spring中由于IoC大量使用LazyLoad技术，即延时加载，在bean真正被调用时才完成初始化。这里用到的是ClassLoader.loadClass。

---

四、JVM内存模型

01. 从线程的角度看JVM内存模型

• 线程私有的内存: 程序计数器、虚拟机栈、本地方法栈
• 所有线程共享的内存: 元空间（MetaSpace）、常量池、堆

1) 程序计数器（Program Counter Register）: 一块较小的内存空间，是当前线程所执行的字节码行号指示器 （逻辑计数器）。改变计数器的值来选取下一条需要执行的字节码指令。和线程是一对一关系，即线程私有；对Java方法，记录的是正在执 行的虚拟机字节码指令的地址；对Native方法，其值为Undefined。 由于只记录行号，不会发生内存泄漏。

2) 虚拟机栈（Stack）: 是Java方法执行的内存模型。每个方法被执行时，都会 创建一个栈帧（方法运行期间的基础数据结构）。

  ① 局部变量表和操作数栈
  局部变量表: 包含方法执行过程中的所有变量
  操作数栈: 入栈、出栈、复制、交换、产生/消费变量
  ② 通过一个简单的加法函数例子来深入理解

	public static int add(int a, int b){
		int c = 0;
		c = a + b;
		return c;
	}

  假设对add方法传入(1, 2)，其过程为：

  ③ 递归为什么会引发java.lang.StackOverflowError异常？
  递归过深，栈帧数超出虚拟栈的深度。解决方法：限制递归深度或者换用迭代方法。
  ④ 总结: 方法执行完成后，栈帧会被自动释放掉，因此不需要GC来回收。
3) 本地方法栈: 与虚拟机栈类似，主要作用于标注了native的方法。
4) 元空间（Meta Space）: JDK 8中把类的元数据放在元空间，而JDK 7及以前的版本是放在永久代（PermGen）中。
  MetaSpace与PermGen相比的优势:
  ① 元空间使用本地内存，永久代使用jvm内存；
  ② 字符串常量池存在永久代中，容易出现性能问题和内存溢出，Meta Space没有了字符串常量池，它被移动到了堆中；
  ③ 类和方法的信息大小难以确定，给永久代的大小指定带来困难；
  ④ 永久代会为GC带来不必要的复杂性，回收效率偏低；
  ⑤ 方便HotSpot与其他JVM（如Jrockit）的集成。
5) 堆（Heap）: 对象实例的分配区域，GC管理的主要区域；

02. 从存储的角度看JVM内存模型
1) JVM三大性能调优参数-Xms、-Xmx、-Xss的含义？

• -Xms堆大小的初始值
• -Xmx堆大小能扩容的最大值
• -Xss规定了每个线程虚拟机栈（堆栈）的大小；

通常-Xms和-Xmx设置成一样的，因为在堆扩容时会发生内存抖动，影响程序运行时的稳定性。
2) 内存分配策略

• 静态存储: 编译时确定每个数据目标在运行时的存储空间需求；
• 栈式存储: 数据区需求在编译时未知，运行时模块入口已确定；
• 堆式存储: 编译时或运行时模块入口都无法确定，动态分配。

3) Java内存模型中堆和栈的区别
联系: 引用对象、数组时，栈里定义变量保存堆中目标的首地址；

区别：
  ① 管理方式: 栈自动释放，堆需要GC；
  ② 空间大小: 一般情况下栈比堆小；
  ③ 碎片相关: 栈产生的碎片远小于堆；
  ④ 分配方式: 栈支持静态和动态分配，堆仅支持动态分配；
  ⑤ 效率: 栈的效率比堆高。

4) Meta Space、堆、线程独占部分的联系
一个HelloWorld的例子：

	public class HelloWorld{
		private String String name;
		public void setName(String name){
			this.name = name;
		}

		public void sayHello(){
			System.out.println("Hello " + name);
		}

		public static void main(String[] args){
			int a = 1;
			HelloWorld hw = new HelloWorld();
			hw.setName("test");
			hw.sayHello();
		}
	}

内存分配：

5) JDK 6和JDK 6+中intern方法的区别

	String s = new String("Test");
	s.intern();

• JDK 6: 当调用intern方法时，如果字符串常量池已创建该字符串对象，则返回池中的该字符串的引用。否则，将此字符串对象添加到字符串常量池中，并返回该字符串对象的引用。
• JDK 6+: 当调用intern方法时，如果字符串常量池已创建该字符串对象，则返回池中的该字符串的引用。否则，如果该字符串对象已经存在于Java堆中，则将堆中对此对象的引用添加到字符串常量池，并且返回该引用；如果堆中不存在，则在池中创建该字符串并返回其引用。

6) 不同JDK中intern方法的功能区别
  ① 代码

		public static void main(String[] args){
			String s = new String("a");
			s.intern();
			String s2 = "a";
			System.out.println(s == s2);

			String s3 = new String("a") + new String("a");
			s3.intern();
			String s4 = "aa";
			System.out.println(s3 == s4);
		}

  ② JDK 6中（输出结果false、false）
  PermGen只存放堆中的副本，不能存放引用，所以s3==s4是false

  ③ JDK 6+中（输出结果false、true）
  堆中的字符串常量池可以存放字符串的引用，所以s3==s4为true

03. 对象在内存中的布局
1) 对象头（Header）: 对象头分为Mark Word和Class Metadata Address两部分，如果对象类型是数组，还要有第三个部分Array Length，即数组长度。

长度	内容	说明
32/64 bits	Mark Word	存储对象的hashCode或锁信息等
32/64 bits	Class Metadata Address	存储对象类型数据的指针
32 bits	Array Length	数组长度（如果对象类型是数组）

Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的 数据，它会根据对象的状态复用自己的存储空间。

  ① 在32位的HotSpot虚拟机中，如果对象处于未被锁定的状态下，那么Mark Word的32bit空间中的25bit用于存储对象哈希码，4bit用于存储对象分代年龄，2bit 用于存储锁标志位，1bit固定为0。

锁状态	25 bits	4 bits	1 bit是否是偏向锁	2 bits锁标志位
无锁	对象的hashCode	对象的分代年龄	0	01

  ② 在 32 位系统下，存放 Class 指针的空间大小是 4 字节，Mark Word 空间大小也是4字节，因此头部就是 8 字节，如果是数组就需要再加 4 字节表示数组的长度。

锁状态	25 bits		4 bits	1 bit	2 bits
	23 bits	2 bits		是否是偏向锁	锁标志位
轻量级锁	指向栈中锁记录的指针				00
重量级锁	指向互斥量（重量级锁）的指针				10
GC标记	空				11
偏向锁	线程ID	Epoch	对象分代年龄	1	01

  ③ 在64位系统及64位JVM下，开启指针压缩，那么头部存放Class指针的空间大小还是4字节，而Mark Word区域会变大，变成8字节，也就是头部最少为12字节。

锁状态	25 bits	31 bits	1 bit	4 bits	1 bit	2 bits
			cms free	分代年龄	偏向锁	锁标志位
无锁	unused	hashCode			0	01
偏向锁	ThreadID(54 bits), Epoch(2 bits)				1	01

2) 实例数据（Instance Data）: 实例数据部分是对象真正存储的有效信息，也是在程序代码中所定义的各种类型的字段内容。这部分的存储顺序会受到虚拟机分配策略参数（FieldsAllocationStyle）和字段在 Java源码中定义顺序的影响。

3) 对齐填充（Padding）: 不是必然存在的，没有特别的含义，它仅起到占位符的作用。由于HotSpot VM的自动内存管理系统要求对象起始地址必须是8字节的整数倍，也就是说对象的大小必须是8字节的整数倍。对象头部分是8字节的倍数，所以当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。

---

后记

JVM的知识点也不少，为便于阅读，我将其分为了基础概念、反射、类加载器ClassLoader和JVM内存模型4个部分。