JVM&GC详解

JVM&GC详解
1.JVM简介
- JVM是java的核心和基础，在java编译器和os平台之间的虚拟处理器。它是一种利用软件方法实现的抽象的计算机基于下层的操作系统和硬件平台，可以在上面执行java的字节码程序。
- java编译器只要面向JVM，生成JVM能理解的代码或字节码文件。Java源文件经编译成字节码程序，通过JVM将每一条指令翻译成不同平台机器码，通过特定平台运行。
运行过程
- Java语言写的源程序通过Java编译器，编译成与平台无关的‘字节码程序’(.class文件，也就是0，1二进制程序)，然后在OS之上的Java解释器中解释执行。
- C++以及Fortran这类编译型语言都会通过一个静态的编译器将程序编译成CPU相关的二进制代码。
- PHP以及Perl这列语言则是解释型语言，只需要安装正确的解释器，它们就能运行在任何CPU之上。当程序被执行的时候，程序代码会被逐行解释并执行。
- 1、编译型语言的优缺点：
  - 速度快：因为在编译的时候它们能够获取到更多的有关程序结构的信息，从而有机会对它们进行优化。
  - 适用性差：它们编译得到的二进制代码往往是CPU相关的，在需要适配多种CPU时，可能需要编译多次。
- 2、解释型语言的优缺点：
  - 适应性强：只需要安装正确的解释器，程序在任何CPU上都能够被运行
  - 速度慢：因为程序需要被逐行翻译，导致速度变慢。同时因为缺乏编译这一过程，执行代码不能通过编译器进行优化。
- 3、Java的做法是找到编译型语言和解释性语言的一个中间点：
  - Java代码会被编译：被编译成Java字节码，而不是针对某种CPU的二进制代码。
  - Java代码会被解释：Java字节码需要被java程序解释执行，此时，Java字节码被翻译成CPU相关的二进制代码。
  - JIT编译器的作用：在程序运行期间，将Java字节码编译成平台相关的二进制代码。正因为此编译行为发生在程序运行期间，所以该编译器被称为Just-In-Time编译器。
2.JVM结构
- java是基于一门虚拟机的语言，所以了解并且熟知虚拟机运行原理非常重要。
2.1 方法区
- 方法区，Method Area，对于习惯在HotSpot虚拟机上开发和部署程序的开发者来说，很多人愿意把方法区称为“永久代”（Permanent Generation），本质上两者并不等价，仅仅是因为HotSpot虚拟机的设计团队选择把GC分代收集扩展至方法区，或者说使用永久代来实现方法区而已。对于其他虚拟机（如BEA JRockit、IBM J9等）来说是不存在永久代的概念的。
- 主要存放已被虚拟机加载的类信息、常量、静态变量、即编译器编译后的代码等数据（比如spring 使用IOC或者AOP创建bean时，或者使用cglib，反射的形式动态生成class信息等）。
注意：JDK 6 时，String等字符串常量的信息是置于方法区中的，但是到了JDK 7 时，已经移动到了Java堆。所以，方法区也好，Java堆也罢，到底详细的保存了什么，其实没有具体定论，要结合不同的JVM版本来分析。

异常
- 当方法区无法满足内存分配需求时，将抛出OutOfMemoryError。
- 运行时常量池溢出：比如一直往常量池加入数据，就会引起OutOfMemoryError异常。
类信息
1. 类型全限定名。
2. 类型的直接超类的全限定名（除非这个类型是java.lang.Object，它没有超类）。
3. 类型是类类型还是接口类型。
4. 类型的访问修饰符（public、abstract或final的某个子集）。
5. 任何直接超接口的全限定名的有序列表。
6. 类型的常量池。
7. 字段信息。
8. 方法信息。
9. 除了常量以外的所有类（静态）变量。
10. 一个到类ClassLoader的引用。
11. 一个到Class类的引用。
2.1.1 常量池

2.1.1.1 Class文件中的常量池
- 在Class文件结构中，最头的4个字节用于存储Megic Number，用于确定一个文件是否能被JVM接受，再接着4个字节用于存储版本号，前2个字节存储次版本号，后2个存储主版本号，再接着是用于存放常量的常量池，由于常量的数量是不固定的，所以常量池的入口放置一个U2类型的数据(constant_pool_count)存储常量池容量计数值。
- 常量池主要用于存放两大类常量：字面量(Literal)和符号引用量(Symbolic References)，字面量相当于Java语言层面常量的概念，如文本字符串，声明为final的常量值等，符号引用则属于编译原理方面的概念，包括了如下三种类型的常量：
  - 类和接口的全限定名
  - 字段名称和描述符
  - 方法名称和描述符
2.1.1.2 运行时常量池
- CLass文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池，用于存放编译器生成的各种字面量和符号引用，这部分内容将在类加载后进入方法区的运行时常量池中存放。
- 运行时常量池相对于CLass文件常量池的另外一个重要特征是具备动态性，Java语言并不要求常量一定只有编译期才能产生，也就是并非预置入CLass文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中，这种特性被开发人员利用比较多的就是String类的intern()方法。
2.1.1.3 常量池的好处
- 常量池是为了避免频繁的创建和销毁对象而影响系统性能，其实现了对象的共享。
- 例如字符串常量池，在编译阶段就把所有的字符串文字放到一个常量池中。
  - （1）节省内存空间：常量池中所有相同的字符串常量被合并，只占用一个空间。
  - （2）节省运行时间：比较字符串时，比equals()快。对于两个引用变量，只用判断引用是否相等，也就可以判断实际值是否相等。
双等号==的含义
- 基本数据类型之间应用双等号，比较的是他们的数值。
- 复合数据类型(类)之间应用双等号，比较的是他们在内存中的存放地址。
2.1.1.4 基本类型的包装类和常量池
- java中基本类型的包装类的大部分都实现了常量池技术，即
```
  Byte,Short,Integer,Long,Character,Boolean
```
- 这5种包装类默认创建了数值[-128，127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。两种浮点数类型的包装类Float,Double并没有实现常量池技术。
Integer与常量池
```
Integer i1 = 40;
Integer i2 = 40;
Integer i3 = 0;
Integer i4 = new Integer(40);
Integer i5 = new Integer(40);
Integer i6 = new Integer(0);
 
System.out.println("i1=i2   " + (i1 == i2));
System.out.println("i1=i2+i3   " + (i1 == i2 + i3));
System.out.println("i1=i4   " + (i1 == i4));
System.out.println("i4=i5   " + (i4 == i5));
System.out.println("i4=i5+i6   " + (i4 == i5 + i6));  
System.out.println("40=i5+i6   " + (40 == i5 + i6));
 
 
i1=i2   true
i1=i2+i3   true
i1=i4   false
i4=i5   false
i4=i5+i6   true
```
- 解释：
  - (1)Integer i1=40；Java在编译的时候会直接将代码封装成Integer i1=Integer.valueOf(40);，从而使用常量池中的对象。
  - (2)Integer i4 = new Integer(40);这种情况下会创建新的对象。
  - (3)语句i4 == i5 + i6，因为+这个操作符不适用于Integer对象，首先i5和i6进行自动拆箱操作，进行数值相加，即i4 == 40。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值40，最终这条语句转为40 == 40进行数值比较。
String与常量池
```
String str1 = "abcd";
String str2 = new String("abcd");
System.out.println(str1==str2);//false
  
String str1 = "str";
String str2 = "ing";
String str3 = "str" + "ing";
String str4 = str1 + str2;
System.out.println(str3 == str4);//false
  
String str5 = "string";
System.out.println(str3 == str5);//true
```
- 解释：
  - (1)new String("abcd")是在常量池中拿对象，"abcd"是直接在堆内存空间创建一个新的对象。只要使用new方法，便需要创建新的对象。
  - (2)连接表达式 + ，只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。
  - 对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中。
```
public static final String A; // 常量A
public static final String B;    // 常量B
static {  
   A = "ab";  
   B = "cd";  
}  
public static void main(String[] args) {  
// 将两个常量用+连接对s进行初始化  
String s = A + B;  
String t = "abcd";  
if (s == t) {  
    System.out.println("s等于t，它们是同一个对象");  
  } else {  
    System.out.println("s不等于t，它们不是同一个对象");  
  }  
}
```
- 解释：
  - s不等于t，它们不是同一个对象。
  - A和B虽然被定义为常量，但是它们都没有马上被赋值。在运算出s的值之前，他们何时被赋值，以及被赋予什么样的值，都是个变数。因此A和B在被赋值之前，性质类似于一个变量。那么s就不能在编译期被确定，而只能在运行时被创建了。
```
String s1 = new String("xyz"); //创建了几个对象？
```
- 解释：
  - 考虑类加载阶段和实际执行时。
    
    （1）类加载对一个类只会进行一次。”xyz”在类加载时就已经创建并驻留了（如果该类被加载之前已经有”xyz”字符串被驻留过则不需要重复创建用于驻留的”xyz”实例）。驻留的字符串是放在全局共享的字符串常量池中的。
    
    （2）在这段代码后续被运行的时候，”xyz”字面量对应的String实例已经固定了，不会再被重复创建。所以这段代码将常量池中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s1 持有。
    
    这条语句创建了2个对象。
```
public static void main(String[] args) {
String s1 = new String("计算机");
String s2 = s1.intern();
String s3 = "计算机";
System.out.println("s1 == s2? " + (s1 == s2));
System.out.println("s3 == s2? " + (s3 == s2));
}
s1 == s2? false
s3 == s2? true
```
- 解释：
  - String的intern()方法会查找在常量池中是否存在一份equal相等的字符串,如果有则返回该字符串的引用,如果没有则添加自己的字符串进入常量池。
2.2 堆
- Heap（堆）是JVM的内存数据区。
- 一个虚拟机实例只对应一个堆空间，堆是线程共享的。堆空间是存放对象实例的地方，几乎所有对象实例都在这里分配。堆也是垃圾收集器管理的主要区域(也被称为GC堆)。堆可以处于物理上不连续的内存空间中，只要逻辑上相连就行。
- Heap 的管理很复杂，每次分配不定长的内存空间，专门用来保存对象的实例。在Heap 中分配一定的内存来保存对象实例，实际上也只是保存对象实例的属性值，属性的类型和对象本身的类型标记等，并不保存对象的方法（方法是指令，保存在Stack中）。而对象实例在Heap中分配好以后，需要在Stack中保存一个4字节的Heap 内存地址，用来定位该对象实例在Heap 中的位置，便于找到该对象实例。
异常
- 堆中没有足够的内存进行对象实例分配时，并且堆也无法扩展时，会抛出OutOfMemoryError异常。
Java栈
- Stack（栈）是JVM的内存指令区。
- 描述的是java方法执行的内存模型：每个方法被执行的时候都会同时创建一个栈帧，用于存放局部变量表（基本类型、对象引用）、操作数栈、方法返回、常量池指针等信息。由编译器自动分配释放，内存的分配是连续的。Stack的速度很快，管理很简单，并且每次操作的数据或者指令字节长度是已知的。所以Java 基本数据类型，Java 指令代码，常量都保存在Stack中。
- 虚拟机只会对栈进行两种操作，以帧为单位的入栈和出栈。Java栈中的每个帧都保存一个方法调用的局部变量、操作数栈、指向常量池的指针等，且每一次方法调用都会创建一个帧，并压栈。
异常
- 如果一个线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常，比如递归调用。
- 如果线程生成数量过多，无法申请足够多的内存时，则会抛出OutOfMemoryError异常。比如tomcat请求数量非常多时，设置最大请求数。
2.3.1 栈帧
- 栈帧由三部分组成：局部变量区、操作数栈、帧数据区。
2.4 堆与栈

2.4.1 堆与栈里存什么
- 1）堆中存的是对象。栈中存的是基本数据类型和堆中对象的引用。一个对象的大小是不可估计的，或者说是可以动态变化的，但是在栈中，一个对象只对应了一个4btye的引用。
- 2）为什么不把基本类型放堆中呢？因为其占用的空间一般是1~8个字节——需要空间比较少，而且因为是基本类型，所以不会出现动态增长的情况——长度固定，因此栈中存储就够了，如果把他存在堆中是没有什么意义的。可以这么说，基本类型和对象的引用都是存放在栈中，而且都是几个字节的一个数，因此在程序运行时，他们的处理方式是统一的。但是基本类型、对象引用和对象本身就有所区别了，因为一个是栈中的数据一个是堆中的数据。最常见的一个问题就是，Java中参数传递时的问题。
- 3）Java中的参数传递时传值呢？还是传引用？程序运行永远都是在栈中进行的，因而参数传递时，只存在传递基本类型和对象引用的问题。不会直接传对象本身。
```
int a = 0; //全局初始化区
 
char p1; //全局未初始化区
 
main(){
 
  int b; //栈
 
  char s[] = "abc"; //栈
 
  char p2; //栈
 
  char p3 = "123456"; //123456在常量区，p3在栈上。
 
  static int c =0； //全局（静态）初始化区
 
  p1 = (char *)malloc(10); //堆
 
  p2 = (char *)malloc(20); //堆
 
}
```
2.4.2 堆内存与栈内存的区别
- 申请和回收方式不同：栈上的空间是自动分配自动回收的，所以栈上的数据的生存周期只是在函数的运行过程中，运行后就释放掉，不可以再访问。而堆上的数据只要程序员不释放空间，就一直可以访问到，不过缺点是一旦忘记释放会造成内存泄露。
- 碎片问题：对于栈，不会产生不连续的内存块；但是对于堆来说，不断的new、delete势必会产生上面所述的内部碎片和外部碎片。
- 申请大小的限制：栈是向低地址扩展的数据结构，是一块连续的内存的区域。栈顶的地址和栈的最大容量是系统预先规定好的，如果申请的空间超过栈的剩余空间，就会产生栈溢出；对于堆，是向高地址扩展的数据结构，是不连续的内存区域。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
- 申请效率的比较：栈由系统自动分配，速度较快。但程序员是无法控制的；堆：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。
3.JIT编译器
1. JIT编译器是JVM的核心。它对于程序性能的影响最大。
2. CPU只能执行汇编代码或者二进制代码，所有程序都需要被翻译成它们，然后才能被CPU执行。
3. C++以及Fortran这类编译型语言都会通过一个静态的编译器将程序编译成CPU相关的二进制代码。
4. PHP以及Perl这列语言则是解释型语言，只需要安装正确的解释器，它们就能运行在任何CPU之上。当程序被执行的时候，程序代码会被逐行解释并执行。
5. 编译型语言的优缺点：
  - 速度快：因为在编译的时候它们能够获取到更多的有关程序结构的信息，从而有机会对它们进行优化。
  - 适用性差：它们编译得到的二进制代码往往是CPU相关的，在需要适配多种CPU时，可能需要编译多次。
6. 解释型语言的优缺点：
  - 适应性强：只需要安装正确的解释器，程序在任何CPU上都能够被运行
  - 速度慢：因为程序需要被逐行翻译，导致速度变慢。同时因为缺乏编译这一过程，执行代码不能通过编译器进行优化。
7. Java的做法是找到编译型语言和解释性语言的一个中间点：
  - Java代码会被编译：被编译成Java字节码，而不是针对某种CPU的二进制代码。
  - Java代码会被解释：Java字节码需要被java程序解释执行，此时，Java字节码被翻译成CPU相关的二进制代码。
  - JIT编译器的作用：在程序运行期间，将Java字节码编译成平台相关的二进制代码。正因为此编译行为发生在程序运行期间，所以该编译器被称为Just-In-Time编译器。
HotSpot 编译
- HotSpot VM名字也体现了JIT编译器的工作方式。在VM开始运行一段代码时，并不会立即对它们进行编译。在程序中，总有那么一些“热点”区域，该区域的代码会被反复的执行。而JIT编译器只会编译这些“热点”区域的代码。
- 这么做的原因在于：
  - 编译那些只会被运行一次的代码性价比太低，直接解释执行Java字节码反而更快。
  - JVM在执行这些代码的时候，能获取到这些代码的信息，一段代码被执行的次数越多，JVM也对它们愈加熟悉，因此能够在对它们进行编译的时候做出一些优化。
- 在HotSpot VM中内嵌有两个JIT编译器，分别为Client Compiler和Server Compiler，但大多数情况下我们简称为C1编译器和C2编译器。开发人员可以通过如下命令显式指定Java虚拟机在运行时到底使用哪一种即时编译器，如下所示：
```
-client：指定Java虚拟机运行在Client模式下，并使用C1编译器；
-server：指定Java虚拟机运行在Server模式下，并使用C2编译器。
```
- 除了可以显式指定Java虚拟机在运行时到底使用哪一种即时编译器外，默认情况下HotSpot VM则会根据操作系统版本与物理机器的硬件性能自动选择运行在哪一种模式下，以及采用哪一种即时编译器。简单来说，C1编译器会对字节码进行简单和可靠的优化，以达到更快的编译速度；而C2编译器会启动一些编译耗时更长的优化，以获取更好的编译质量。不过在Java7版本之后，一旦开发人员在程序中显式指定命令“-server”时，缺省将会开启分层编译（Tiered Compilation）策略，由C1编译器和C2编译器相互协作共同来执行编译任务。不过在早期版本中，开发人员则只能够通过命令“-XX:+TieredCompilation”手动开启分层编译策略。
- 总结
  - Java综合了编译型语言和解释性语言的优势。
  - Java会将类文件编译成为Java字节码，然后Java字节码会被JIT编译器选择性地编译成为CPU能够直接运行的二进制代码。
  - 将Java字节码编译成二进制代码后，性能会被大幅度提升。
4.类加载机制
- Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的加载机制。
- 类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括了：加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（using）、和卸载（Unloading）七个阶段。其中验证、准备和解析三个部分统称为连接（Linking），这七个阶段的发生顺序如下图所示：
- 如上图所示，加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的，类的加载过程必须按照这个顺序来按部就班地开始，而解析阶段则不一定，它在某些情况下可以在初始化阶段后再开始。
- 类的生命周期的每一个阶段通常都是互相交叉混合式进行的，通常会在一个阶段执行的过程中调用或激活另外一个阶段。
4.1 类加载的时机

主动引用
- 一个类被主动引用之后会触发初始化过程（加载，验证，准备需再此之前开始）
  - 1）遇到new、get static、put static或invoke static这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令最常见的Java代码场景是：使用new关键字实例化对象时、读取或者设置一个类的静态字段（被final修饰、已在编译器把结果放入常量池的静态字段除外）时、以及调用一个类的静态方法的时候。
  - 2）使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
  - 3）当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要触发父类的初始化。
  - 4）当虚拟机启动时，用户需要指定一个执行的主类（包含main()方法的类），虚拟机会先初始化这个类。
  - 5）当使用jdk7+的动态语言支持时，如果java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发器初始化。
被动引用
- 一个类如果是被动引用的话，该类不会触发初始化过程
  - 1）通过子类引用父类的静态字段，不会导致子类初始化。对于静态字段，只有直接定义该字段的类才会被初始化，因此当我们通过子类来引用父类中定义的静态字段时，只会触发父类的初始化，而不会触发子类的初始化。
  - 2）通过数组定义来引用类，不会触发此类的初始化。
  - 3）常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
4.2 类加载过程

1、加载
- 在加载阶段，虚拟机需要完成以下三件事情：
  - 1）通过一个类的全限定名称来获取定义此类的二进制字节流。
  - 2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
  - 3）在java堆中生成一个代表这个类的java.lang.Class对象，作为方法区这些数据的访问入口。
- 相对于类加载过程的其他阶段，加载阶段是开发期相对来说可控性比较强，该阶段既可以使用系统提供的类加载器完成，也可以由用户自定义的类加载器来完成，开发人员可以通过定义自己的类加载器去控制字节流的获取方式。
2、验证
- 验证的目的是为了确保Class文件中的字节流包含的信息符合当前虚拟机的要求，而且不会危害虚拟机自身的安全。不同的虚拟机对类验证的实现可能会有所不同，但大致都会完成以下四个阶段的验证：文件格式的验证、元数据的验证、字节码验证和符号引用验证。
  - 1）文件格式的验证：验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理，该验证的主要目的是保证输入的字节流能正确地解析并存储
    于方法区之内。经过该阶段的验证后，字节流才会进入内存的方法区中进行存储，后面的三个验证都是基于方法区的存储结构进行的。
  - 2）元数据验证：对类的元数据信息进行语义校验（其实就是对类中的各数据类型进行语法校验），保证不存在不符合Java语法规范的元数据信息。
  - 3）字节码验证：该阶段验证的主要工作是进行数据流和控制流分析，对类的方法体进行校验分析，以保证被校验的类的方法在运行时不会做出危害虚拟机安全的行为。
  - 4）符号引用验证：这是最后一个阶段的验证，它发生在虚拟机将符号引用转化为直接引用的时候（解析阶段中发生该转化，后面会有讲解），主要是对类自身以外的信息（常量池中的各种符号引用）进行匹配性的校验。
3、准备
- 准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些内存都将在方法区中进行分配。
  - 注：
    
    1）这时候进行内存分配的仅包括类变量（static），而不包括实例变量，实例变量会在对象实例化时随着对象一块分配在Java堆中。
    
    2）这里所设置的初始值通常情况下是数据类型默认的零值（如0、0L、、false等），而不是被在Java代码中被显式地赋予的值。
4、解析
- 解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。
符号引用（Symbolic Reference）：

-符号引用以一组符号来描述所引用的目标，符号引用可以是任何形式的字面量，符号引用与虚拟机实现的内存布局无关，引用的目标并不一定已经在内存中。

直接引用（Direct Reference）：
- 直接引用可以是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。直接引用是与虚拟机实现的内存布局相关的，同一个符号引用在不同的虚拟机实例上翻译出来的直接引用一般都不相同，如果有了直接引用，那引用的目标必定已经在内存中存在。
  - 1）类或接口的解析：判断所要转化成的直接引用是对数组类型，还是普通的对象类型的引用，从而进行不同的解析。
  - 2）字段解析：对字段进行解析时，会先在本类中查找是否包含有简单名称和字段描述符都与目标相匹配的字段，如果有，则查找结束；如果没有，则会按照继承关系从上往下递归搜索该类所实现的各个接口和它们的父接口，还没有，则按照继承关系从上往下递归搜索其父类，直至查找结束。
  - 3）类方法解析：对类方法的解析与对字段解析的搜索步骤差不多，只是多了判断该方法所处的是类还是接口的步骤，而且对类方法的匹配搜索，是先搜索父类，再搜索接口。
  - 4）接口方法解析：与类方法解析步骤类似，只是接口不会有父类，因此，只递归向上搜索父接口就行了。
5、初始化
- 类初始化阶段是类加载过程的最后一步，前面的类加载过程中，除了加载（Loading）阶段用户应用程序可以通过自定义类加载器参与之外，其余动作完全由虚拟机主导和控制。到了初始化阶段，才真正开始执行类中定义的Java程序代码。
- 初始化阶段是执行类构造器
  方法的过程。
  
  1）方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序所决定。
  
  2）方法与类的构造函数不同，它不需要显式地调用父类构造器，虚拟机会保证在子类的方法执行之前，父类的方法已经执行完毕，因此在虚拟机中第一个执行的方法的类一定是java.lang.Object。
  
  3）由于父类的方法先执行，也就意味着父类中定义的静态语句块要优先于子类的变量赋值操作。
  
  4）方法对于类或者接口来说并不是必需的，如果一个类中没有静态语句块也没有对变量的赋值操作，那么编译器可以不为这个类生成方法。
  
  5）接口中可能会有变量赋值操作，因此接口也会生成方法。但是接口与类不同，执行接口的方法不需要先执行父接口的方法。只有当父接口中定义的变量被使用时，父接口才会被初始化。另外，接口的实现类在初始化时也不会执行接口的方法。
  
  6）虚拟机会保证一个类的方法在多线程环境中被正确地加锁和同步。如果有多个线程去同时初始化一个类，那么只会有一个线程去执行这个类的方法，其它线程都需要阻塞等待，直到活动线程执行方法完毕。如果在一个类的方法中有耗时很长的操作，那么就可能造成多个进程阻塞。
5.垃圾回收

5.1 按代实现垃圾回收

新生代（Young generation）:
- 绝大多数最新被创建的对象会被分配到这里，由于大部分对象在创建后会很快变得不可到达，所以很多对象被创建在新生代，然后消失。对象从这个区域消失的过程我们称之为”minor GC“。
- 新生代中存在一个Eden区和两个Survivor区。新对象会首先分配在 Eden 中(如果新对象过大，会直接分配在老年代中)。在GC中，Eden 中的对象会被移动到survivor中，直至对象满足一定的年纪(定义为熬过GC的次数),会被移动到老年代
- 可以设置新生代和老年代的相对大小。这种方式的优点是新生代大小会随着整个堆大小动态扩展。参数 -XX:NewRatio 设置老年代与新生代的比例。例如 -XX:NewRatio=8 指定老年代/新生代为8/1. 老年代占堆大小的 7/8 ，新生代占 1/8 .(默认即使1/8)
```
  例如：-XX:NewSize=64m -XX:MaxNewSize=1024m -XX:NewRatio=8
```
老年代（Old generation）:
- 对象没有变得不可达，并且从新生代中存活下来，会被拷贝到这里。其所占用的空间要比新生代多。也正由于其相对较大的空间，发生在老年代上的GC要比新生代少得多。对象从老年代中消失的过程，可以称之为“old GC”
永久代（permanent generation）:
- 像一些类的层级信息，方法数据和方法信息（如字节码，栈和变量大小），运行时常量池（jdk7之后移出永久代），已确定的符号引用和虚方法表等等，它们几乎都是静态的并且很少被卸载和回收，在JDK8之前的HotSpot虚拟机中，类的这些“永久的”数据存放在一个叫做永久代的区域。永久代一段连续的内存空间，我们在JVM启动之前可以通过设置-XX:MaxPermSize的值来控制永久代的大小。但是jdk8之后取消了永久代，这些元数据被移到了一个与堆不相连的本地内存区域。
5.2 怎样判断对象是否已经死亡

引用计数收集算法
- 用计数是垃圾收集器中的早期策略。在这种方法中，堆中每个对象（不是引用）都有一个引用计数。当一个对象被创建时，且将该对象分配给一个变量，该变量计数设置为1。当任何其它变量被赋值为这个对象的引用时，计数加1（a = b,则b引用的对象+1），但当一个对象的某个引用超过了生命周期或者被设置为一个新值时，对象的引用计数减1。任何引用计数为0的对象可以被当作垃圾收集。当一个对象被垃圾收集时，它引用的任何对象计数减1。
- 优点：引用计数收集器可以很快的执行，交织在程序运行中。对程序不被长时间打断的实时环境比较有利。
- 缺点：无法检测出循环引用。如父对象有一个对子对象的引用，子对象反过来引用父对象。这样，他们的引用计数永远不可能为0.
可达性分析算法
- 通过一系列称为”GC Roots”的对象作为起点，从这些节点开始向下搜索，搜索所有走过的路径称为引用链，当一个对象到GC Roots没有任何引用链相连时(从GC Roots到此对象不可达)，则证明此对象是不可用的。
- 可作为GC Roots的对象包括：
  - 虚拟机栈中所引用的对象（本地变量表）
  - 方法区中类静态属性引用的对象
  - 方法区中常量引用的对象
  - 本地方法栈中JNI引用的对象（Native对象）
5.3 java中的引用

强引用(Strong Reference):
- 在代码中普遍存在的，类似”Object obj = new Object”这类引用，只要强引用还在，垃圾收集器永远不会回收掉被引用的对象
软引用(Sofe Reference):
- 有用但并非必须的对象，可用SoftReference类来实现软引用，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行二次回收。如果这次回收还没有足够的内存，才会抛出内存异常异常。
弱引用(Weak Reference):
- 被弱引用关联的对象只能生存到下一次垃圾收集发生之前，JDK提供了WeakReference类来实现弱引用。
虚引用(Phantom Reference):
- 也称为幽灵引用或幻影引用，是最弱的一种引用关系，JDK提供了PhantomReference类来实现虚引用。
5.4 finalize方法什么作用
- 对于一个对象来说，在被判断没有 GCroots 与其相关联时，被第一次标记，然后判断该对象是否应该执行finalize方法（判断依据：如果对象的finalize方法被复写，并且没有执行过，则可以被执行）。如果允许执行那么这个对象将会被放到一个叫F-Query的队列中，等待被执行。（注意：由于finalize的优先级比较低，所以该对象的的finalize方法不一定被执行，即使被执行了，也不保证finalize方法一定会执行完）
5.5 垃圾收集算法

标记-清除算法：
- 标记-清除算法采用从根集合进行扫描，对存活的对象进行标记，标记完毕后，再扫描整个空间中未被标记的对象，进行回收。标记-清除算法不需要进行对象的移动，并且仅对不存活的对象进行处理，在存活对象比较多的情况下极为高效，但由于标记-清除算法直接回收不存活的对象，因此会造成内存碎片。
复制算法：
- 这种收集算法将堆栈分为两个域，常称为半空间。每次仅使用一半的空间，JVM生成的新对象则放在另一半空间中。GC运行时，它把可到达对象复制到另一半空间，从而压缩了堆栈。这种方法适用于短生存期的对象，持续复制长生存期的对象则导致效率降低。并且对于指定大小堆来说，需要两倍大小的内存，因为任何时候都只使用其中的一半。
标记整理算法：
- 标记-整理算法采用标记-清除算法一样的方式进行对象的标记，但在清除时不同，在回收不存活的对象占用的空间后，会将所有的存活对象往一端空闲空间移动，并更新对应的指针。标记-整理算法是在标记-清除算法的基础上，又进行了对象的移动，因此成本更高，但是却解决了内存碎片的问题。
分代收集算法：
- 在上边三种收集思想中加入了分代的思想。
5.6 Hotspot实现垃圾回收细节

一致性：
- 在可达性分析期间整个系统看起来就像被冻结在某个时间点上，不可以出现分析过程中对象引用关系还在不断变化的情况。
- 一致性要求导致GC进行时必须停顿所有Java执行线程。（Stop The World）即使在号称不会发生停顿的CMS收集器中，枚举根节点时也是必须停顿的。
- HotSpot使用的是准确式GC，当执行系统停顿下来后，并不需要一个不漏地检查完所有执行上下文和全局的引用位置，这是通过一组称为OopMap的数据结构来达到的。
安全点（Safe Point）：
- 程序只有在到达安全点时才能暂停。安全点的选定标准是“是否具有让程序长时间执行的特征”。“长时间执行”的最明显特征就是指令序列的复用，如方法调用、循环跳转等，具有这些功能的指令才会产生安全点。
让程序暂停的两种方式：
```
* 抢先式中断（Preemptive Suspension）：在GC发生时，主动中断所有线程，不需要线程执行的代码主动配合。如果发现有线程中断的地方不在安全点上，就恢复线程让它跑到安全点上。（不推荐）
* 主动式中断（Voluntary Suspension）：设一个标志，各个线程主动去轮询这个标志，遇到中断则暂停。轮询地方与安全点重合。
```
5.7 CMS收集器

特性：
- CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。目前很大一部分的Java应用集中在互联网站或者B/S系统的服务端上，这类应用尤其重视服务的响应速度，希望系统停顿时间最短，以给用户带来较好的体验。CMS收集器就非常符合这类应用的需求。
- CMS收集器是基于“标记—清除”算法实现的，它的运作过程相对于前面几种收集器来说更复杂一些，整个过程分为4个步骤：
  - 初始标记（CMS initial mark）：初始标记仅仅只是标记一下GC Roots能直接关联到的对象，速度很快，需要“Stop The World”。
  - 并发标记（CMS concurrent mark）：并发标记阶段就是进行GC Roots Tracing的过程。
  - 重新标记（CMS remark）：重新标记阶段是为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段稍长一些，但远比并发标记的时间短，仍然需要“Stop The World”。
  - 并发清除（CMS concurrent sweep）：并发清除阶段会清除对象。
- 由于整个过程中耗时最长的并发标记和并发清除过程收集器线程都可以与用户线程一起工作，所以，从总体上来说，CMS收集器的内存回收过程是与用户线程一起并发执行的。
优点：
- CMS是一款优秀的收集器，它的主要优点在名字上已经体现出来了：并发收集、低停顿。
缺点：
- 1）CMS收集器对CPU资源非常敏感
  - 其实，面向并发设计的程序都对CPU资源比较敏感。在并发阶段，它虽然不会导致用户线程停顿，但是会因为占用了一部分线程（或者说CPU资源）而导致应用程序变慢，总吞吐量会降低。
  - CMS默认启动的回收线程数是（CPU数量+3）/ 4，也就是当CPU在4个以上时，并发回收时垃圾收集线程不少于25%的CPU资源，并且随着CPU数量的增加而下降。但是当CPU不足4个（譬如2个）时，CMS对用户程序的影响就可能变得很大。
- 2）CMS收集器无法处理浮动垃圾
  - CMS收集器无法处理浮动垃圾，可能出现“Concurrent Mode Failure”失败而导致另一次Full GC的产生。
  - 由于CMS并发清理阶段用户线程还在运行着，伴随程序运行自然就还会有新的垃圾不断产生，这一部分垃圾出现在标记过程之后，CMS无法在当次收集中处理掉它们，只好留待下一次GC时再清理掉。这一部分垃圾就称为“浮动垃圾”。
  - 也是由于在垃圾收集阶段用户线程还需要运行，那也就还需要预留有足够的内存空间给用户线程使用，因此CMS收集器不能像其他收集器那样等到老年代几乎完全被填满了再进行收集，需要预留一部分空间提供并发收集时的程序运作使用。要是CMS运行期间预留的内存无法满足程序需要，就会出现一次“Concurrent Mode Failure”失败，这时虚拟机将启动后备预案：临时启用Serial Old收集器来重新进行老年代的垃圾收集，这样停顿时间就很长了。
- 3）CMS收集器会产生大量空间碎片
  - CMS是一款基于“标记—清除”算法实现的收集器，这意味着收集结束时会有大量空间碎片产生。空间碎片过多时，将会给大对象分配带来很大麻烦，往往会出现老年代还有很大空间剩余，但是无法找到足够大的连续空间来分配当前对象，不得不提前触发一次Full GC。
5.8 G1收集器

特性：
- G1（Garbage-First）是一款面向服务端应用的垃圾收集器。HotSpot开发团队赋予它的使命是未来可以替换掉JDK 1.5中发布的CMS收集器。与其他GC收集器相比，G1具备如下特点。
  - 1)并行与并发
    
    G1能充分利用多CPU、多核环境下的硬件优势，使用多个CPU来缩短Stop-The-World停顿的时间，部分其他收集器原本需要停顿Java线程执行的GC动作，G1收集器仍然可以通过并发的方式让Java程序继续执行。
  - 2)分代收集
    
    与其他收集器一样，分代概念在G1中依然得以保留。虽然G1可以不需要其他收集器配合就能独立管理整个GC堆，但它能够采用不同的方式去处理新创建的对象和已经存活了一段时间、熬过多次GC的旧对象以获取更好的收集效果。
  - 3)空间整合
    
    与CMS的“标记—清理”算法不同，G1从整体来看是基于“标记—整理”算法实现的收集器，从局部（两个Region之间）上来看是基于“复制”算法实现的，但无论如何，这两种算法都意味着G1运作期间不会产生内存空间碎片，收集后能提供规整的可用内存。这种特性有利于程序长时间运行，分配大对象时不会因为无法找到连续内存空间而提前触发下一次GC。
  - 4)可预测的停顿
    
    这是G1相对于CMS的另一大优势，降低停顿时间是G1和CMS共同的关注点，但G1除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒。
- 在G1之前的其他收集器进行收集的范围都是整个新生代或者老年代，而G1不再是这样。使用G1收集器时，Java堆的内存布局就与其他收集器有很大差别，它将整个Java堆划分为多个大小相等的独立区域（Region），虽然还保留有新生代和老年代的概念，但新生代和老年代不再是物理隔离的了，它们都是一部分Region（不需要连续）的集合。
- G1收集器之所以能建立可预测的停顿时间模型，是因为它可以有计划地避免在整个Java堆中进行全区域的垃圾收集。G1跟踪各个Region里面的垃圾堆积的价值大小（回收所获得的空间大小以及回收所需时间的经验值），在后台维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的Region（这也就是Garbage-First名称的来由）。这种使用Region划分内存空间以及有优先级的区域回收方式，保证了G1收集器在有限的时间内可以获取尽可能高的收集效率。
执行过程：
- G1收集器的运作大致可划分为以下几个步骤：
  - 1）初始标记（Initial Marking）：初始标记阶段仅仅只是标记一下GC Roots能直接关联到的对象，并且修改TAMS（Next Top at Mark Start）的值，让下一阶段用户程序并发运行时，能在正确可用的Region中创建新对象，这阶段需要停顿线程，但耗时很短。
  - 2）并发标记（Concurrent Marking）：并发标记阶段是从GC Root开始对堆中对象进行可达性分析，找出存活的对象，这阶段耗时较长，但可与用户程序并发执行。
  - 3）最终标记（Final Marking）：最终标记阶段是为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线程Remembered Set Logs里面，最终标记阶段需要把Remembered Set Logs的数据合并到Remembered Set中，这阶段需要停顿线程，但是可并行执行。
  - 4）筛选回收（Live Data Counting and Evacuation）：筛选回收阶段首先对各个Region的回收价值和成本进行排序，根据用户所期望的GC停顿时间来制定回收计划，这个阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分Region，时间是用户可控制的，而且停顿用户线程将大幅提高收集效率。
```
何时会抛出OutOfMemoryException，并不是内存被耗空的时候才抛出
    * JVM98%的时间都花费在内存回收
    * 每次回收的内存小于2%
```
相关阅读:
手游产品经理初探（十）竞品分析
 Openfire开发配置,Openfire源码配置,OpenFire二次开发配置
 code forces 148D Bag of mice （概率DP）
Android Studio怎样更改JDK和SDK的路径？
bbb
收集了三年的最好的设计站点
 C# foreach 有用方法具体解释
 Java 过滤器的作用
 SVD神秘值分解
 《C语言编写学生成绩管理系统》
原文地址：https://www.cnblogs.com/jun-zi/p/12149657.html

1.JVM简介

运行过程

2.JVM结构

2.1 方法区

异常

类信息

2.1.1 常量池

2.1.1.1 Class文件中的常量池

2.1.1.2 运行时常量池

2.1.1.3 常量池的好处

双等号==的含义

2.1.1.4 基本类型的包装类和常量池

Integer与常量池

String与常量池

2.2 堆

异常

Java栈

异常

2.3.1 栈帧

2.4 堆与栈

2.4.1 堆与栈里存什么

2.4.2 堆内存与栈内存的区别

3.JIT编译器

HotSpot 编译

4.类加载机制

4.1 类加载的时机

主动引用

被动引用

4.2 类加载过程

1、加载

2、验证

3、准备

4、解析

符号引用（Symbolic Reference）：

直接引用（Direct Reference）：

5、初始化

5.垃圾回收

5.1 按代实现垃圾回收

新生代（Young generation）:

老年代（Old generation）:

永久代（permanent generation）:

5.2 怎样判断对象是否已经死亡

引用计数收集算法

可达性分析算法

5.3 java中的引用

强引用(Strong Reference):

软引用(Sofe Reference):

弱引用(Weak Reference):

虚引用(Phantom Reference):

5.4 finalize方法什么作用

5.5 垃圾收集算法

标记-清除算法：

复制算法：

标记整理算法：

分代收集算法：

5.6 Hotspot实现垃圾回收细节

一致性：

安全点（Safe Point）：

让程序暂停的两种方式：

5.7 CMS收集器

特性：

优点：

缺点：

5.8 G1收集器

特性：

执行过程：