一篇笔记整理JVM工作原理

ゞ浴缸里的玫瑰 2022-01-21 21:29 225阅读 0赞

**前言：**

想提高Java开发，了解jvm是必不可少的。它让开发者了解他们的代码，jvm是如何变异与运行。深入了解jvm：会让你的代码写的高效，逐步成为大神

**下面介绍jvm的基本知识**

### >>数据类型 ###

Java虚拟机中，数据类型可以分为两类：**基本类型和引用类型**。

基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。

“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。

基本类型包括：**byte，boolean（1 byte），short，char（2 bytes），int，float（4 bytes），long，double（8 bytes），returnAddress（不确定是否是基本类型）**

引用类型包括：**类类型，接口类型和数组。**

### >>堆与栈 ###

栈是运行时的单位，而堆是存储的单位。

栈解决程序的运行问题，即程序如何执行，或者说如何处理数据；堆解决的是数据存储的问题，即数据怎么放、放在哪儿。

在Java中一个线程就会相应有一个线程栈与之对应，这点很容易理解，因为不同的线程执行逻辑有所不同因此需要一个独立的线程栈。而堆则是所有线程共享的。栈因为是运行单位，因此里面存储的信息都是跟当线程（或程序）相关信息的。包括局部变量、程序运行状态、方法返回值等等；而堆只负责存储对象信息。

堆中存的是对象。栈中存的是基本数据类型和堆中对象的引用。

堆和栈中，栈是程序运行最根本的东西。程序运行可以没有堆，但是不能没有栈。而堆是为栈进行数据存储服务，说白了堆就是一块共享的内存。不过，正是因为堆和栈的分离的思想，才使得Java的垃圾回收成为可能。

Java中，栈的大小通过-Xss来设置，当栈中存储数据比较多时，需要适当调大这个值，否则会出现java.lang.StackOverflowError异常。常见的出现这个异常的是无法返回的递归，因为此时栈中保存的信息都是方法返回的记录点。

**>>Java中的参数传递时传值呢？还是传引用？**

**　　**要说明这个问题，先要明确两点：

1. 不要试图与C进行类比，Java中没有指针的概念。

2. 程序运行永远都是在栈中进行的，因而参数传递时，只存在传递基本类型和对象引用的问题。不会直接传对象本身。

明确以上两点后。Java在方法调用传递参数时，因为没有指针，所以它都是进行传值调用（这点可以参考C的传值调用）。因此，很多书里面都说Java是进行传值调用，这点没有问题，而且也简化的C中复杂性。

传值传引用都不够准确，可以理解成传引用变量的副本值。引用变量分为字面值引用变量（即基本数据类型引用变量）和对象引用变量 。 详情需要了解数据类型使用机制和堆栈的概念：http://www.cnblogs.com/alexlo/archive/2013/02/21/2920209.html

对象引用变量：即普通java对象的引用变量 ，如 String a = "abc" , a就是对象引用变量。java 是不能直接操作对象的，只能通过对“对象引用的操作”来操作对象。而对象的引用的表示就是对象变量。可以多个对象引用变量指向同一个对象。  
　　字面值引用变量：即普通数据类型的引用变量 ，如 int b = 1 , b就是字面值引用变量。可以有多个字面值引用变量指向同一字面值，但其中一个引用修改字面值，不会影响另一个引用字面值，这点要与对象引用区别开。

### >>Java对象的大小 ###

基本数据的类型的大小是固定的，Java基本数据类型与位运算，这里就不多说了。对于非基本类型的Java对象，其大小就值得商榷。在Java中，一个空Object对象的大小是8byte，这个大小只是保存堆中一个没有任何属性的对象的大小。看下面语句：

<table> 
 <tbody> 
 <tr> 
 <td> 1 </td> 
 <td> <code>Object ob =&nbsp;</code><code>new</code>&nbsp;<code>Object();</code> </td> 
 </tr> 
 </tbody> 
</table>

这样在程序中完成了一个Java对象的生命，但是它所占的空间为：4byte(栈)+8byte(堆)。4byte是上面部分所说的Java栈中保存引用的所需要的空间。而那8byte则是Java堆中对象的信息。因为所有的Java非基本类型的对象都需要默认继承Object对象，因此不论什么样的Java对象，其大小都必须是大于8byte。

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 </td> 
 <td> <code>Class NewObject { </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>int</code>&nbsp;<code>count;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>boolean</code>&nbsp;<code>flag;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Object ob;</code> <code>}</code> </td> 
 </tr> 
 </tbody> 
</table>

其大小为：空对象大小(8byte)+int大小(4byte)+Boolean大小(1byte)+空Object引用的大小(4byte)=17byte。

但是因为Java在对对象内存分配时都是以8的整数倍来分，因此大于17byte的最接近8的整数倍的是24，因此此对象的大小为24byte。

这里需要注意一下基本类型的包装类型的大小。因为这种包装类型已经成为对象了，因此需要把他们作为对象来看待。包装类型的大小至少是12byte（声明一个空Object至少需要的空间），而且12byte没有包含任何有效信息，同时，因为Java对象大小是8的整数倍，因此一个基本类型包装类的大小至少是16byte。这个内存占用是很恐怖的，它是使用基本类型的N倍（N>2），有些类型的内存占用更是夸张（随便想下就知道了）。

因此，可能的话应尽量少使用包装类。在JDK5.0以后，因为加入了自动类型装换，因此，Java虚拟机会在存储方面进行相应的优化。

### >>引用类型 ###

对象引用类型分为强引用、软引用、弱引用和虚引用。

强引用:就是我们一般声明对象时虚拟机生成的引用，强引用环境下，垃圾回收时需要严格判断当前对象是否被强引用，如果被强引用，则不会被垃圾回收。

软引用:软引用一般被做为缓存来使用。与强引用的区别是，软引用在垃圾回收时，虚拟机会根据当前系统的剩余内存来决定是否对软引用进行回收。如果剩余内存比较紧张，则虚拟机会回收软引用所引用的空间；如果剩余内存相对富裕，则不会进行回收。换句话说，虚拟机在发生OutOfMemory时，肯定是没有软引用存在的。

弱引用:弱引用与软引用类似，都是作为缓存来使用。但与软引用不同，弱引用在进行垃圾回收时，是一定会被回收掉的，因此其生命周期只存在于一个垃圾回收周期内。

强引用不用说，我们系统一般在使用时都是用的强引用。而“软引用”和“弱引用”比较少见。他们一般被作为缓存使用，而且一般是在内存大小比较受限的情况下做为缓存。因为如果内存足够大的话，可以直接使用强引用作为缓存即可，同时可控性更高。因而，他们常见的是被使用在桌面应用系统的缓存。

## JVM的生命周期 ##

**一、首先分析两个概念**  
　　 JVM实例和JVM执行引擎实例  
　　（1）JVM实例对应了一个独立运行的java程序，它是进程级别。  
　　（2）JVM执行引擎实例则对应了属于用户运行程序的线程，它是线程级别的。

### 二、JVM的生命周期 ###

（1）JVM实例的诞生：当启动一个Java程序时，一个JVM实例就产生了，任何一个拥有public static void main(String\[\] args)函数的class都可以作为JVM实例运行的起点。

（2）JVM实例的运行 main()作为该程序初始线程的起点，任何其他线程均由该线程启动。JVM内部有两种线程：守护线程和非守护线程，main()属于非守护线程，守护线程通常由JVM自己使用，java程序也可以标明自己创建的线程是守护线程。

（3）JVM实例的消亡：当程序中的所有非守护线程都终止时，JVM才退出；若安全管理器允许，程序也可以使用Runtime类或者System.exit()来退出。

## JVM的体系结构 ##

![724399-20161018224805045-165730412.jpg][]

### 　　一、JVM的内部体系结构分为三部分， ###

（1）类装载器（ClassLoader）子系统  
　　　　　作用: 用来装载.class文件  
　　（2）执行引擎  
　　　　　作用:执行字节码，或者执行本地方法  
　　（3）运行时数据区  
　　　　　方法区，堆，java栈，PC寄存器，本地方法栈

## JVM类加载器 ##

![724399-20161018225024763-1807607336.png][]

### 一、 JVM将整个类加载过程划分为了三个步骤： ###

（1）装载  
　　装载过程负责找到二进制字节码并加载至JVM中，JVM通过类名、类所在的包名通过ClassLoader来完成类的加载，同样，也采用以上三个元素来标识一个被加载了的类：类名+包名+ClassLoader实例ID。  
（2）链接  
　　链接过程负责对二进制字节码的格式进行校验、初始化装载类中的静态变量以及解析类中调用的接口、类。在完成了校验后，JVM初始化类中的静态变量，并将其值赋为默认值。最后一步为对类中的所有属性、方法进行验证，以确保其需要调用的属性、方法存在，以及具备应的权限（例如public、private域权限等），会造成NoSuchMethodError、NoSuchFieldError等错误信息。  
（3）初始化  
　　初始化过程即为执行类中的静态初始化代码、构造器代码以及静态属性的初始化，在四种情况下初始化过程会被触发执行：调用了new；反射调用了类中的方法；子类调用了初始化；JVM启动过程中指定的初始化类。

### 二、JVM两种类装载器包括：启动类装载器和用户自定义类装载器： ###

启动类装载器是JVM实现的一部分，用户自定义类装载器则是Java程序的一部分，必须是ClassLoader类的子类。

主要分为以下几类：  
　　(1) Bootstrap ClassLoader  
　　这是JVM的根ClassLoader，它是用C++实现的，JVM启动时初始化此ClassLoader，并由此ClassLoader完成$JAVA\_HOME中jre/lib/rt.jar（Sun JDK的实现）中所有class文件的加载，这个jar中包含了java规范定义的所有接口以及实现。  
　　(2) Extension ClassLoader  
　　JVM用此classloader来加载扩展功能的一些jar包  
　　(3) System ClassLoader  
　　JVM用此classloader来加载启动参数中指定的Classpath中的jar包以及目录，在Sun JDK中ClassLoader对应的类名为AppClassLoader。  
　　(4) User-Defined ClassLoader  
　　User-DefinedClassLoader是Java开发人员继承ClassLoader抽象类自行实现的ClassLoader，基于自定义的ClassLoader可用于加载非Classpath中的jar以及目录

### 三、ClassLoader抽象类提供了几个关键的方法： ###

（1）loadClass  
　　此方法负责加载指定名字的类，ClassLoader的实现方法为先从已经加载的类中寻找，如没有则继续从parent ClassLoader中寻找，如仍然没找到，则从System ClassLoader中寻找，最后再调用findClass方法来寻找，如要改变类的加载顺序，则可覆盖此方法  
（2）findLoadedClass  
　　此方法负责从当前ClassLoader实例对象的缓存中寻找已加载的类，调用的为native的方法。  
（3） findClass  
　　此方法直接抛出ClassNotFoundException，因此需要通过覆盖loadClass或此方法来以自定义的方式加载相应的类。  
(4) findSystemClass  
　　此方法负责从System ClassLoader中寻找类，如未找到，则继续从Bootstrap ClassLoader中寻找，如仍然为找到，则返回null。  
(5)defineClass   
　　此方法负责将二进制的字节码转换为Class对象  
(6) resolveClass  
　　此方法负责完成Class对象的链接，如已链接过，则会直接返回。

### 四、简单的classLoader例子 ###

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 </td> 
 <td> <code>/*</code> <code>* 重写ClassLoader类的findClass方法，将一个字节数组转换为 Class 类的实例</code> <code>*/</code> <code>public</code>&nbsp;<code>Class&lt;?&gt; findClass(String name)&nbsp;</code><code>throws</code>&nbsp;<code>ClassNotFoundException { </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>byte</code><code>[] b =&nbsp;</code><code>null</code><code>;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>try</code>&nbsp;<code>{ </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>b = loadClassData(AutoClassLoader.FormatClassName(name));</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>}&nbsp;</code><code>catch</code>&nbsp;<code>(Exception e) { </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>e.printStackTrace();</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>}</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>return</code>&nbsp;<code>defineClass(name, b,&nbsp;</code><code>0</code><code>, b.length);</code> <code>}</code> <code>/*</code> <code>* 将指定路径的.class文件转换成字节数组</code> <code>*/</code> <code>private</code>&nbsp;<code>byte</code><code>[] loadClassData(String filepath)&nbsp;</code><code>throws</code>&nbsp;<code>Exception { </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>int</code>&nbsp;<code>n =</code><code>0</code><code>;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>BufferedInputStream br =&nbsp;</code><code>new</code>&nbsp;<code>BufferedInputStream(</code><code>new</code>&nbsp;<code>FileInputStream(</code><code>new</code>&nbsp;<code>File(filepath)));</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>ByteArrayOutputStream bos=&nbsp;</code><code>new</code>&nbsp;<code>ByteArrayOutputStream();</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>while</code><code>((n=br.read())!=-</code><code>1</code><code>){ </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>bos.write(n);</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>}</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>br.close();</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>return</code>&nbsp;<code>bos.toByteArray();</code> <code>}</code> <code>/*</code> <code>* 格式化文件所对应的路径</code> <code>*/</code> <code>public</code>&nbsp;<code>static</code>&nbsp;<code>String FormatClassName(String name){ </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>FILEPATH= DEAFAULTDIR + name+</code><code>".class"</code><code>;</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>return</code>&nbsp;<code>FILEPATH;</code> <code>}</code> <code>&nbsp;</code>&nbsp; <code>/*</code> <code>* main方法测试</code> <code>*/</code> <code>public</code>&nbsp;<code>static</code>&nbsp;<code>void</code>&nbsp;<code>main(String[] args)&nbsp;</code><code>throws</code>&nbsp;<code>Exception { </code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>AutoClassLoader acl =&nbsp;</code><code>new</code>&nbsp;<code>AutoClassLoader();</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Class c = acl.findClass(</code><code>"testClass"</code><code>);</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Object obj = c.newInstance();</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Method m = c.getMethod(</code><code>"getName"</code><code>,</code><code>new</code>&nbsp;<code>Class[]{String.</code><code>class</code>&nbsp;<code>,</code><code>int</code><code>.</code><code>class</code><code>});</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>m.invoke(obj,</code><code>"你好"</code><code>,</code><code>123</code><code>);</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>System.out.println(c.getName());</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>System.out.println(c.getClassLoader());</code> <code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>System.out.println(c.getClassLoader().getParent());</code> <code>}&nbsp;&nbsp;&nbsp;</code> </td> 
 </tr> 
 </tbody> 
</table>

## JVM执行引擎 ##

### 一、JVM通过执行引擎来完成字节码的执行，在执行过程中JVM采用的是自己的一套指令系统 ###

每个线程在创建后，都会产生一个程序计数器（pc）和栈（Stack），其中程序计数器中存放了下一条将要执行的指令，Stack中存放Stack Frame，栈帧，表示的为当前正在执行的方法，每个方法的执行都会产生Stack Frame，Stack Frame中存放了传递给方法的参数、方法内的局部变量以及操作数栈，操作数栈用于存放指令运算的中间结果，指令负责从操作数栈中弹出参与运算的操作数，指令执行完毕后再将计算结果压回到操作数栈，当方法执行完毕后则从Stack中弹出，继续其他方法的执行。

在执行方法时JVM提供了invokestatic、invokevirtual、invokeinterface和invokespecial四种指令来执行

（1）invokestatic：调用类的static方法 
（2） invokevirtual： 调用对象实例的方法 
（3） invokeinterface：将属性定义为接口来进行调用 
（4） invokespecial： JVM对于初始化对象（Java构造器的方法为：<init>）以及调用对象实例中的私有方法时。

### 二、反射机制是Java的亮点之一，基于反射可动态调用某对象实例中对应的方法、访问查看对象的属性等 ###

而无需在编写代码时就确定需要创建的对象，这使得Java可以实现很灵活的实现对象的调用，代码示例如下：

Class actionClass=Class.forName(外部实现类);  
Method method=actionClass.getMethod(“execute”,null);  
Object action=actionClass.newInstance();  
method.invoke(action,null);

反射的关键：**要实现动态的调用，最明显的方法就是动态的生成字节码，加载到JVM中并执行。**

（1）Class actionClass=Class.forName(外部实现类);  
　　调用本地方法，使用调用者所在的ClassLoader来加载创建出Class对象；  
（2）Method method=actionClass.getMethod(“execute”,null);  
　　校验此Class是否为public类型的，以确定类的执行权限，如不是public类型的，则直接抛出SecurityException;调用privateGetDeclaredMethods来获取到此Class中所有的方法，在privateGetDeclaredMethods对此Class中所有的方法的集合做了缓存，在第一次时会调用本地方法去获取；

*扫描方法集合列表中是否有相同方法名以及参数类型的方法，如有则复制生成一个新的Method对象返回；  
如没有则继续扫描父类、父接口中是否有此方法，如仍然没找到方法则抛出NoSuchMethodException；  
（3） Object action=actionClass.newInstance();  
第一步：校验此Class是否为public类型，如权限不足则直接抛出SecurityException；  
第二步：如没有缓存的构造器对象，则调用本地方法获取到构造器，并复制生成一个新的构造器对象，放入缓存，如没有空构造器则抛出InstantiationException；  
第三步：校验构造器对象的权限；  
第四步：执行构造器对象的newInstance方法；构造器对象的newInstance方法判断是否有缓存的ConstructorAccessor对象，如果没有则调用sun.reflect.ReflectionFactory生成新的ConstructorAccessor对象；  
第五步：sun.reflect.ReflectionFactory判断是否需要调用本地代码，可通过sun.reflect.noInflation=true来设置为不调用本地代码，在不调用本地代码的情况下，就转交给MethodAccessorGenerator来处理了；  
第六步：MethodAccessorGenerator中的generate方法根据Java Class格式规范生成字节码，字节码中包括了ConstructorAccessor对象需要的newInstance方法，此newInstance方法对应的指令为invokespecial，所需的参数则从外部压入，生成的Constructor类的名字以：sun/reflect/GeneratedSerializationConstructorAccessor或sun/reflect/GeneratedConstructorAccessor开头，后面跟随一个累计创建的对象的次数；  
第七步：在生成了字节码后将其加载到当前的ClassLoader中，并实例化，完成ConstructorAccessor对象的创建过程，并将此对象放入构造器对象的缓存中；  
最后一步：执行获取的constructorAccessor.newInstance，这步和标准的方法调用没有任何区别。*

（4） method.invoke(action,null);  
这步执行的过程和上一步基本类似，只是在生成字节码时生成的方法改为了invoke，其调用的目标改为了传入的对象的方法，同时生成的类名改为了：sun/reflect/GeneratedMethodAccessor。  
注：但是getMethod是非常耗性能的，一方面是权限的校验，另外一方面所有方法的扫描以及Method对象的复制，因此在使用反射调用多的系统中应缓存getMethod返回的Method对象

2、执行技术  
主要的执行技术有:解释，即时编译，自适应优化、芯片级直接执行  
（1）解释属于第一代JVM，  
（2）即时编译JIT属于第二代JVM，  
（3）自适应优化（目前Sun的HotspotJVM采用这种技术）则吸取第一代JVM和第二代JVM的经验，采用两者结合的方式  
（4）自适应优化：开始对所有的代码都采取解释执行的方式，并监视代码执行情况，然后对那些经常调用的方法启动一个后台线程，将其编译为本地代码，并进行仔细优化。若方法不再频繁使用，则取消编译过的代码，仍对其进行解释执行。

[724399-20161018224805045-165730412.jpg]: /images/20220122/4519f1edcf6f41168867a0b29c3e7b78.png
[724399-20161018225024763-1807607336.png]: /images/20220122/7e4dc7870c034e6482de928ba126e6e4.png