转载

目录

---

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 基本类型的包装类和常量池

   2.2 堆
   2.3 Java栈

    2.3.1 栈帧
    2.3.1.1 局部变量区
    2.3.1.2 操作数栈
    2.3.1.3 栈数据区

   2.4 本地方法栈
   2.5 PC寄存器
   2.6 堆与栈

    2.6.1 堆与栈里存什么
    2.6.2 堆内存与栈内存的区别

3. JIT编译器

4. 类加载机制
   4.1 类加载的时机
   4.2 类加载过程

5. 垃圾回收
   5.1 按代实现垃圾回收
   5.2 怎样判断对象是否已经死亡
   5.3 java中的引用
   5.4 finalize方法什么作用
   5.5 垃圾收集算法
   5.6 Hotspot实现垃圾回收细节
   5.7 垃圾收集器

    5.7.1 Serial收集器
    5.7.2 ParNew收集器
    5.7.3 Parallel Scavenge收集器
    5.7.4 Serial Old收集器
    5.7.5 Parallel Old收集器
    5.7.6 CMS收集器
    5.7.7 G1收集器

6. JVM参数
   6.1 典型配置

    6.1.1 堆大小设置
    6.1.2 回收器选择
    6.1.3 辅助信息

   6.2 参数详细说明

7. JVM性能调优
   7.1 堆设置调优
   7.2 GC策略调优
   7.3 JIT调优
   7.4 JVM线程调优
   7.5 典型案例

8. 常见问题
   8.1 内存泄漏及解决方法
   8.2 年老代堆空间被占满
   8.3 持久代被占满
   8.4 堆栈溢出
   8.5 线程堆栈满
   8.6 系统内存被占满

---

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时，可能需要编译多次。

解释型语言的优缺点：

• 适应性强：只需要安装正确的解释器，程序在任何CPU上都能够被运行

• 速度慢：因为程序需要被逐行翻译，导致速度变慢。同时因为缺乏编译这一过程，执行代码不能通过编译器进行优化。

Java的做法是找到编译型语言和解释性语言的一个中间点：

• Java代码会被编译：被编译成Java字节码，而不是针对某种CPU的二进制代码。

• Java代码会被解释：Java字节码需要被java程序解释执行，此时，Java字节码被翻译成CPU相关的二进制代码。

• JIT编译器的作用：在程序运行期间，将Java字节码编译成平台相关的二进制代码。正因为此编译行为发生在程序运行期间，所以该编译器被称为Just-In-Time编译器。

---

image.png

image.png

2.JVM结构

image.png

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   truei1=i2+i3   truei1=i4   falsei4=i5   falsei4=i5+i6   true40=i5+i6   true

解释：

• (1)Integer i1=40；Java在编译的时候会直接将代码封装成Integer i1=Integer.valueOf(40);，从而使用常量池中的对象。

• (2)Integer i1 = 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);//falseString str1 = "str";String str2 = "ing";String str3 = "str" + "ing";String str4 = str1 + str2;System.out.println(str3 == str4);//falseString str5 = "string";System.out.println(str3 == str5);//true

解释：

• (1)new String("abcd")是在常量池中拿对象，"abcd"是直接在堆内存空间创建一个新的对象。只要使用new方法，便需要创建新的对象。

• (2)连接表达式 +
  只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。
  对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中。

public static final String A; // 常量Apublic static final String B;    // 常量Bstatic {  
   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? falses3 == s2? true

解释：

String的intern()方法会查找在常量池中是否存在一份equal相等的字符串,如果有则返回该字符串的引用,如果没有则添加自己的字符串进入常量池。

public class Test {public static void main(String[] args) { String hello = "Hello", lo = "lo";
 System.out.println((hello == "Hello") + " "); //true
 System.out.println((Other.hello == hello) + " "); //true
 System.out.println((other.Other.hello == hello) + " "); //true
 System.out.println((hello == ("Hel"+"lo")) + " "); //true
 System.out.println((hello == ("Hel"+lo)) + " "); //false
 System.out.println(hello == ("Hel"+lo).intern()); //true
 }
}class Other { static String hello = "Hello";
}


package other;public class Other { public static String hello = "Hello";
}

解释：

在同包同类下,引用自同一String对象.

在同包不同类下,引用自同一String对象.

在不同包不同类下,依然引用自同一String对象.

在编译成.class时能够识别为同一字符串的,自动优化成常量,引用自同一String对象.

在运行时创建的字符串具有独立的内存地址,所以不引用自同一String对象.

2.2 堆

Heap（堆）是JVM的内存数据区。

一个虚拟机实例只对应一个堆空间，堆是线程共享的。堆空间是存放对象实例的地方，几乎所有对象实例都在这里分配。堆也是垃圾收集器管理的主要区域(也被称为GC堆)。堆可以处于物理上不连续的内存空间中，只要逻辑上相连就行。

Heap 的管理很复杂，每次分配不定长的内存空间，专门用来保存对象的实例。在Heap 中分配一定的内存来保存对象实例，实际上也只是保存对象实例的属性值，属性的类型和对象本身的类型标记等，并不保存对象的方法（方法是指令，保存在Stack中）。而对象实例在Heap中分配好以后，需要在Stack中保存一个4字节的Heap 内存地址，用来定位该对象实例在Heap 中的位置，便于找到该对象实例。

异常

堆中没有足够的内存进行对象实例分配时，并且堆也无法扩展时，会抛出OutOfMemoryError异常。

image.png

2.3 Java栈

Stack（栈）是JVM的内存指令区。

描述的是java方法执行的内存模型：每个方法被执行的时候都会同时创建一个栈帧，用于存放局部变量表（基本类型、对象引用）、操作数栈、方法返回、常量池指针等信息。 由编译器自动分配释放， 内存的分配是连续的。Stack的速度很快，管理很简单，并且每次操作的数据或者指令字节长度是已知的。所以Java 基本数据类型，Java 指令代码，常量都保存在Stack中。

虚拟机只会对栈进行两种操作，以帧为单位的入栈和出栈。Java栈中的每个帧都保存一个方法调用的局部变量、操作数栈、指向常量池的指针等，且每一次方法调用都会创建一个帧，并压栈。

异常

• 如果一个线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常， 比如递归调用。

• 如果线程生成数量过多，无法申请足够多的内存时，则会抛出OutOfMemoryError异常。比如tomcat请求数量非常多时，设置最大请求数。

2.3.1 栈帧

栈帧由三部分组成：局部变量区、操作数栈、帧数据区。

2.3.1.1 局部变量区

包含方法的参数和局部变量。

以一个静态方法为例

public class Demo {     public static int doStaticMethod(int i, long l, float f, Object o, byte b) {         return 0;
     }
 }

编译之后的具备变量表字节码如下：

LOCALVARIABLEiIL0L10
LOCALVARIABLElJL0L11
LOCALVARIABLEfFL0L13
LOCALVARIABLEoLjava/lang/Object;L0L14
LOCALVARIABLEbBL0L15
MAXSTACK=1    //该方法操作栈的最大深度MAXLOCALS=6  //确定了该方法所需要分配的最大局部变量表的容量

可以认为Java栈帧里的局部变量表有很多的槽位组成，每个槽最大可以容纳32位的数据类型，故方法参数里的int i 参数占据了一个槽位，而long l 参数就占据了两个槽（1和2），Object对象类型的参数其实是一个引用，o相当于一个指针，也就是32位大小。byte类型升为int，也是32位大小。如下：

0 int int i1 long long l3 float float f4 reference Object o5 int byte b

实例方法的局部变量表和静态方法基本一样，唯一区别就是实例方法在Java栈帧的局部变量表里第一个槽位（0位置）存的是一个this引用（当前对象的引用），后面就和静态方法的一样了。

2.3.1.2 操作数栈

Java没有寄存器，故所有参数传递使用Java栈帧里的操作数栈，操作数栈被组织成一个以字长为单位的数组，它是通过标准的栈操作-入栈和出栈来进行访问，而不是通过索引访问。

看一个例子：

image.png

注意，对于局部变量表的槽位，按照从0开始的顺序，依次是方法参数，之后是方法内的局部变量，局部变量0就是a，1就是b，2就是c…… 编译之后的字节码为：

// access flags 0x9
  public static add(II)I
   L0
    LINENUMBER 18 L0 // 对应源代码第18行，以此类推
    ICONST_0 // 把常量0 push 到Java栈帧的操作数栈里
    ISTORE 2 // 将0从操作数栈pop到局部变量表槽2里（c），完成赋值
   L1
    LINENUMBER 19 L1
    ILOAD 0 // 将局部变量槽位0（a）push 到Java栈帧的操作数栈里
    ILOAD 1 // 把局部变量槽1（b）push到操作数栈 
    IADD // pop出a和b两个变量，求和，把结果push到操作数栈
    ISTORE 2 // 把结果从操作数栈pop到局部变量2（a+b的和给c赋值）
   L2
    LINENUMBER 21 L2
    ILOAD 2 // 局部变量2（c）push 到操作数栈
    IRETURN // 返回结果
   L3
    LOCALVARIABLE a I L0 L3 0
    LOCALVARIABLE b I L0 L3 1
    LOCALVARIABLE c I L1 L3 2
    MAXSTACK = 2
    MAXLOCALS = 3

发现，整个计算过程的参数传递和操作数栈密切相关！如图：

image.png

2.3.1.3 栈数据区

存放一些用于支持常量池解析（常量池指针）、正常方法返回以及异常派发机制的信息。即将常量池的符号引用转化为直接地址引用、恢复发起调用的方法的帧进行正常返回，发生异常时转交异常表进行处理。

2.4 本地方法栈

Native Method Stack

访问本地方式时使用到的栈，为本地方法服务， 也就是调用虚拟机使用到的Native方法服务。也会抛出StackOverflowError和OutOfMemoryError异常。

2.5 PC寄存器

每个线程都拥有一个PC寄存器，线程私有的。
PC寄存器的内容总是下一条将被执行指令的"地址"，这里的"地址"可以是一个本地指针，也可以是在方法字节码中相对于该方法起始指令的偏移量。如果该线程正在执行一个本地方法，则程序计数器内容为undefined，区域在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

2.6 堆与栈

2.6.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\0在常量区，p3在栈上。

  static int c =0； //全局（静态）初始化区

  p1 = (char *)malloc(10); //堆

  p2 = (char *)malloc(20); //堆}

2.6.2 堆内存与栈内存的区别

• 申请和回收方式不同：栈上的空间是自动分配自动回收的，所以栈上的数据的生存周期只是在函数的运行过程中，运行后就释放掉，不可以再访问。而堆上的数据只要程序员不释放空间，就一直可以访问到，不过缺点是一旦忘记释放会造成内存泄露。

• 碎片问题：对于栈，不会产生不连续的内存块；但是对于堆来说，不断的new、delete势必会产生上面所述的内部碎片和外部碎片。

• 申请大小的限制：栈是向低地址扩展的数据结构，是一块连续的内存的区域。栈顶的地址和栈的最大容量是系统预先规定好的，如果申请的空间超过栈的剩余空间，就会产生栈溢出；对于堆，是向高地址扩展的数据结构，是不连续的内存区域。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

• 申请效率的比较：栈由系统自动分配，速度较快。但程序员是无法控制的；堆：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。

3.JIT编译器

1. JIT编译器是JVM的核心。它对于程序性能的影响最大。

2. CPU只能执行汇编代码或者二进制代码，所有程序都需要被翻译成它们，然后才能被CPU执行。

3. C++以及Fortran这类编译型语言都会通过一个静态的编译器将程序编译成CPU相关的二进制代码。

4. PHP以及Perl这列语言则是解释型语言，只需要安装正确的解释器，它们就能运行在任何CPU之上。当程序被执行的时候，程序代码会被逐行解释并执行。

5. 编译型语言的优缺点：

• 速度快：因为在编译的时候它们能够获取到更多的有关程序结构的信息，从而有机会对它们进行优化。

• 适用性差：它们编译得到的二进制代码往往是CPU相关的，在需要适配多种CPU时，可能需要编译多次。

解释型语言的优缺点：

• 适应性强：只需要安装正确的解释器，程序在任何CPU上都能够被运行

• 速度慢：因为程序需要被逐行翻译，导致速度变慢。同时因为缺乏编译这一过程，执行代码不能通过编译器进行优化。

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”手动开启分层编译策略。

总结

1. Java综合了编译型语言和解释性语言的优势。

2. Java会将类文件编译成为Java字节码，然后Java字节码会被JIT编译器选择性地编译成为CPU能够直接运行的二进制代码。

3. 将Java字节码编译成二进制代码后，性能会被大幅度提升。

4.类加载机制

Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的加载机制。

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括了：加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（using）、和卸载（Unloading）七个阶段。其中验证、准备和解析三个部分统称为连接（Linking），这七个阶段的发生顺序如下图所示：

image.png

如上图所示，加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的，类的加载过程必须按照这个顺序来按部就班地开始，而解析阶段则不一定，它在某些情况下可以在初始化阶段后再开始。

类的生命周期的每一个阶段通常都是互相交叉混合式进行的，通常会在一个阶段执行的过程中调用或激活另外一个阶段。

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程序代码。

初始化阶段是执行类构造器<clinit>方法的过程。

• 1）<clinit>方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序所决定。

• 2）<clinit>方法与类的构造函数不同，它不需要显式地调用父类构造器，虚拟机会保证在子类的<clinit>方法执行之前，父类的<clinit>方法已经执行完毕，因此在虚拟机中第一个执行的<clinit>方法的类一定是java.lang.Object。

• 3）由于父类的<clinit>方法先执行，也就意味着父类中定义的静态语句块要优先于子类的变量赋值操作。

• 4）<clinit>方法对于类或者接口来说并不是必需的，如果一个类中没有静态语句块也没有对变量的赋值操作，那么编译器可以不为这个类生成<clinit>方法。

• 5）接口中可能会有变量赋值操作，因此接口也会生成<clinit>方法。但是接口与类不同，执行接口的<clinit>方法不需要先执行父接口的<clinit>方法。只有当父接口中定义的变量被使用时，父接口才会被初始化。另外，接口的实现类在初始化时也不会执行接口的<clinit>方法。

• 6）虚拟机会保证一个类的<clinit>方法在多线程环境中被正确地加锁和同步。如果有多个线程去同时初始化一个类，那么只会有一个线程去执行这个类的<clinit>方法，其它线程都需要阻塞等待，直到活动线程执行<clinit>方法完毕。如果在一个类的<clinit>方法中有耗时很长的操作，那么就可能造成多个进程阻塞。