JVM类加载机制简述以及一个小口诀_类加载 口诀

JVM类加载机制简述

小目标

• 知道一个类加载的全过程
• 理解类加载的各阶段在做什么

类加载过程以及一个小口诀

JVM类加载分为5个过程：加载，验证，准备，解析，初始化,后面的使用,加上后面的使用,卸载,就是类的生命周期了.如下图所示：

这里有个小口诀:
家宴准姐出(加验准解初)
​ 理论上来说这样的整个流程顺序是没有什么问题的,加载,验证,准备,初始化,卸载这五个阶段顺序是确定的,类加载必须按照这样的顺序的,但是解析阶段就不一定了,它在某些情况下是可以在初始化之后再开始的,这是为了支持java语言的运行时绑定(也称动态绑定或晚期绑定).

注意:
这里的顺序不是说一个结束以后再开始另一个,而是这些阶段通常是互相交叉的运行的,会在一个阶段的执行过程中调用,激活另一个阶段,只是因为阶段开始时间是会有先后,所以才按照这个先后进行排序

例如:加载的过程中需要将字节流所代表的静态存储结构转化为方法区的运行时数据结构,但是这些字节流需要完成验证的第一个阶段-文件格式验证,通过后才能被允许进入Java虚拟机内存的方法区中进行存储.而验证的其他的步骤需要在加载完成以后进行.

1 加载

​ 作为类加载整个流程的一个阶段,这个阶段需要完成三件事情:

1. 通过一个类的全限定名来获取定义此类的二进制字节流.

2. 将这个字节流所代表的静态储存接口转化为方法区运行时数据结构.

3. 在堆中生成一个代表这个类的java.lang.Class对象,作为方法区这个类的个数据的访问入口.

​ "通过一个类的全限定名来获取定义此类的二进制字节流"这条规则,其实并没有限定指明二进制字节流必须得从某个Class文件中获取,确切的说都没有指明从哪里获取,怎么获取,那么充满创造力的开发者们则玩出了不同的花样.

• 从ZIP压缩包中读取,这是最常见的,如JAR,EAR,WAR等格式
• 从网络中获取,这种场景最典型的应用就是Web Applet
• 运行时计算生成,这种场景使用的最多的就是动态代理技术,在java.lang.reflect.Proxy中,就是用了ProxyGenerator.generator.ProxyClass()来为特定的接口生成形式为"*$Proxy"的代理类的二进制字节流.
• 由于其他文件的生成,典型的是JSP应用,有JSP文件生成对应的Class文件
• …

个人觉得动态代理的底层技术与类的记载过程有些关系,可以研究研究.

加载阶段结束后,JVM外部的二进制字节流按照虚拟机所设定的格式存储在防区中了,方法区中的数据存储完全由JVM实现自行定义,但是<Java 虚拟机规范>中并没有规定此区域的具体数据结构.类型数据妥善安置在方法去以后,会在Java堆中实例化一个java.lang.Class类的对象,这个对象将作为程序访问方法区中类型数据的外部接口.

2 验证

​ 这个阶段是连接阶段的第一步,目的是确保Class文件的字节流中包含的信息符合<Java 虚拟机规范>的全部约束要求,保证这些信息被当做代码运行后不会危害虚拟机自身的安全.

​ 这个阶段是飞常重要的,这个阶段是否严谨,直接决定了Java虚拟机是否能承受恶意代码的攻击,从代码量和耗费的执行性能的角度上讲,验证阶段的工作量在虚拟机的类加载阶过程中占了相当大的比重.

2.1.文件格式验证(字节流中Class文件格式规范验证)

验证的第一阶段就是进行文件格式验证,看看字节流是否符合Class文件格式的规范,并且能被当前版本的虚拟机处理.这一阶段可能包括下面几个验证点:

• 是否已魔数0xCAFEBABE开头

• 主,次版本号是否在当前Java虚拟机接受范围之内.

• 常量池的常量中是否有不被支持的常量类型(检查常量tag标志)

• 指向常量的各种索引值中是否执行不存在的常量或不符合类型的常量.

• CONSTANT_Utf8_info型的常量中是否有不符合UTF-8编码的数据

• Class 文件中各个部分及文件本身是否有被删除的或附加的其他信息

• …

  这个阶段的验证是基于二进制字节流进行的,只有通过了这个阶段的验证之后,这阶段字节流才被允许进入Java虚拟机内存的方法区中进行存储,所以后面的三个验证阶段全部是基于方法区的存储结构上进行的,不会在直接读取,操作字节流了.

2.2.原数据验证(继承关系,接口实现验证)

​ 第二阶段是对字节码描述的信息进行语义分析,以保证其描述的信息符合<Java 语言规范>的要求,包括以下几个验证点:

• 这个类是否有父类(除了Object,其他的都应该有)

• 这类的父类是否继承了不允许继承的类(被final修饰的类)

• 如果这个类不是抽象类,是否实现了其父类或接口中要求实现的所有方法

• 类中的字段,方法是否与父类产生矛盾(例如覆盖了父类的final字段,或者出现不符合规则的方法重载,例如方法参数都一致,但返回值类型却不同等)

• …

  这阶段主要的母的就是堆类的原数据信息进行予以校验,保证不存在与<Java 语言规范>定义相悖的元数据信息

2.3.字节码验证(Class方法体验证,赋值关系进行验证)

​ 第三阶段是整个验证过程中最复杂的一个阶段,主要是通过对数据流分析和控制流分析,确定程序语法是否合法,复合逻辑.在第二阶段对原数据信息中的数据类型校验完毕以后,这阶段就要对类的方法体(Class文件中的Code属性)进行校验分析,保证被验证类的方法在运行时不会做出危害虚拟机安全的行为

• 保证任意时刻操作数栈的数据类型与指令代码序列都能配合工作,例如不会出现类似于"在操作栈放置了一个int类型的数据,使用时却按照long 类型来加载入本地变量表中"这样的情况
• 保证任何跳转指令都不会跳转到方法体以外的字节码指令上
• 保证方法体中的类型转换总是有效的,例如可以把一个子类对象赋值给父类数据类型,这是安全的,但是把父类对象赋值给子类数据类型,甚至把对象赋值给与他毫无继承关系,完全不相干的数据类型,则是危险和不合法的
• …

2.4.符号引用验证(符号引用的类是否存在,是否有访问的权限)

​ 验证的最后阶段,是为了校验行为发生在虚拟机将符号引用转化为直接引用时,这个转化动作将在链接的第三阶段------解析中发生.符号引用验证可以看做是对类自身以外(常量池中的各种符号引用)的各类信息进行匹配性检验,通俗来说就是,改类是否缺少或者被禁止访问它依赖的某些外部类,方法,字段等资源.

• 符号引用中通过字符串描述的全限定名是否能找到对应的类.

• 在指定类中是否存在类方法的字段描述符及简单名称所描述的方法和字段.

• 符号引用中的类,字段,方法的可访问性(private,protected,public,)是否被当前类访问

• …

  验证夹断对于虚拟机的类加载机制来说,是一个非常重要的,但却不是必须要执行的阶段,因为验证阶段只有通过或者不通过的差别,只要通过了验证,其后就是程序运行期没有任何影响了.

3 准备

​ 准备阶段是正式为类中定义的变量(即静态变量,被static修饰的变量)分配内存并设置类变量初始值的阶段,从概念上讲,这些变量所使用的内存都应该在方法区中进行分配,单必须注意到的方法区本身是一个逻辑上的区域,在JDK1.7及之前,HotSpot使用永久代来实现方法区时就是种逻辑概念;但是在JDK1.8及以后,类变量则会随着Class对象一起放在Java堆中,这时候"类变量在方法区"就完全是一种对逻辑概念的描述了.

​ 这时候进行内存分配的仅包括类变量,而不包括实例变量,实例变量将会在对象实例化时随着对象一起分配的仅包括类变量,而不包括视力表量,实例变量将会在对象实例化时候随着对象一起分配在Java堆中.再者这里所说的初始值"通常情况下"是数据类型的零值;

public static int value=123;//准备阶段后,value的值是0而不是123,类变量的赋值要等到初始化阶段(putstatic命令执行后)
public static final int value2=123;//准备阶段后value2的值是123,static final修饰的字段是常量,在编译阶段就会生成ConstantValue属性,在准备阶段JVM就会根据该属性的设置将value2赋值为123
1
2

基本数据类型的零值表

4 解析

​ 解析阶段是Java虚拟机将常量池内的符号引用替换为直接引用的过程,符号引用在Class文件中它以CONSTANT_Class_info,CONSTANT_Fieldref_info,CONSTANT_Methodref_info等类型的常量出现,解析阶段中所说的直接引用与符号引用的关联:

• 符号引用(Symbolic References):符号引用以一组符号来描述锁引用的目标,符号可以是任何形式的字面量,只要使用时能无歧义地定位到目标即可.符号引用与虚拟机实现的内存布局无关,引用的是目标并不一定是已经加载到虚拟机内存中的内容.各种虚拟机实现的内存布局可以各不相同,但是它们能接受的符号引用必须是一致的,因为符号引用的字面量形式明确定义在<Java 虚拟机规范>的Class文件格式中.

• 直接引用(Direc References):直接引用是可以直接指向目标的指针(指向类的Class对象,类变量以及类方法直接指向逻辑上的方法区),相对偏移量或者是一个能间接定位到目标的句柄.直接以用是虚拟机实现的额内存布局直接相关的,同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同.如果有了直接引用,那引用的目标必定已经在虚拟机的内存中存在.

  package com.example;
  
  import com.example.language;
  
  
  public class People {
     
      private Language language;
      
      public People(){
          
      }
      
      public Language get(){
          return this.language;
      }
  
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

​ 上面是全限定名为com.example.People的类,其中引用了com.example.Language类,在编译时,JVM不知道Language的实际地址,因此在CONSTANT_Class_info中用一个常量(符号引用)表示Language这个类的地址,在解析时候,会将这个CONSTANT_Class_info常量(符号引用)的值拿出来并找到com.example.Language的Class对象地址,用这个Class对象地址替换这个符号引用

解析的过程中可以看出,如果需要解析com.example.People,必须先加载com.example.Language, 加载完成后,还需要保证com.example.People必须有访问com.example.Language的权限;由此可以看出,如果加载的类中有父类,其他类的引用,那么需要先加载这些类,这些类加载结束才能加载当前类.

5 初始化

​ 类的初始化阶段是类的加载过程的最后一个步骤,之前介绍的几个类加载的动作里,除了在加载阶段用户应用程序可以通过自定义加载器的方式局部参与外,其余动作都完全由Java虚拟机来主导控制.直到初始化阶段,Java虚拟机才真正执行类中编写的Java程序代码,将主导权交给应用程序.

​ 初始化话阶段的时机<Java虚拟机规范> 是有严格要求的

1. 遇到new,getstatic,putstatic或invokestatic这四条字节码指令时,如果类型没有初始化,则需要先触发其初始化阶段,这四种经典场景:

   • 使用new关键字实例化对象时候.
   • 读取或设置一个类型的静态字段(被final修饰,已经在编译期把结果放入常量池的静态字段除外)的时候
   • 调用一个类型的额静态方法的时候

2. 使用java.lang.reflect 包的方法对类型进行反射调用的时候,如果类型没有进行初始化,则需要先触发其初始化

3. 当初始化类的时候,如果发现其父类还没有进行过初始化,则需要先触发其父类的初始化

4. 当虚拟机启动时,用户需要制定一个要执行的主类(包含main()方法的那个类)

5. 当使用JDK1.7新加入的动态语言支持时,如果一个java.lang.invoke.MethodHandle实例最后的解析结果为REF_getstatic,REF_putstatic,REF_invokestatic,REF_newInvokeSpecial四种类型的方法句柄,并且这个方法句柄对应的类没有进行过初始化,则需要先触发其初始化

6. 当一个类接口中定义了JDK8新加入的默认方法(被default关键字修饰的接口方法)时,如果有这个接口的实现类发生了初始化,那该接口要在其之前被初始化

   有几点需要主要的:

   1. 通过子类去引用父类的静态字段,不会导致子类初始化

      public class SuperClass{
          static{
              System.out.println("SuperClass init");
          }
          public static int value=123
      }
      
      
      public class SubClass extends SpuerClass{
          static{
               System.out.println("SubClass init");
          }
      }
      
      
      public class NotInitialization{
          public static void main(String[] args){
              System.out.println(SubClass.value);
          }
      }
      
      //输出:
      SuperClass init
      123
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24

   2. 常量在编译阶段会存入调用类的常量池中,本质上没有直接引用到定义常量的类,因此不会触发定义常量类的初始化

      public class ConstantCalss{
          static{
               System.out.println("ConstantCalss init");
          }
          public static final String VALUE="abc";
      }
      
      public class NotInitialization{
          public static void main(String[] args){
              System.out.println(ConstantCalss.VALUE);
          }
      }
      //输出结果:
      abc
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14

   这六种场景的行为称为对一个类型进行主动引用.

进行准备阶段是,变量已经赋值过一次系统要求的零值,而在初始化阶段,则会根据程序员通过编码指定的主观计划去初始化类变量和其他资源.

​ 我们也可以从另外一种更直接的形式来表达:初始化阶段就是执行类构造器()方法的过程.()并不是程序员在Java代码中直接编写的方法,而是Javac编译器的自动生成物,但我们非常有必要勒戒这个方法是如何产生的,以及()方法执行过程中各种可能会影响程序运行行为的细节,这部分比起其他类加载过程更贴近于普通的程序开发人员的实际工作.

• ()方法是有编译器自动收集类中的所有类变量的赋值动作和静态语句块中的语句合并产生的,编译器收集的顺序是有语句在源文件中出现的顺序决定的,静态语句块中只能访问到定义在静态语句块之前的变量,定义在它之后的变量,在前面的静态语句块中可以赋值,但不能被访问.

public class Test{
    static{
        i=0;//给变量赋值可以征程编译通过
        System.out.print(i)//这句编译器会是"非法向前引用"
    }
    static int i=1;
}

1
2
3
4
5
6
7
8

• ()方法与类的构造函数(即在JVM视角中的实例构造器()方法)不同,它不需要显示地调用父类构造器,Java虚拟机会保证在子类的()方法执行前,父类的()已经执行完毕,因此在JVM虚拟机中第一个被执行的()方法的类型肯定是java.lang.Object.

• 由于父类的()方法先执行,也就意味着父类中定义的今天语句块要优先于子类的变量赋值操作

• ()方法对于类或者接口来说并不是必须的,如果一个类中没有静态语句块,也没有对变量的赋值操作,那么编译器可以不为这个类生成()方法

• 接口中不能使用静态语句块,但仍然有变量初始化的赋值操作,因此接口与类一样都会发生()方法.但接口与类不同的是,执行接口的()方法不需要先执行父接口的()方法,因为只有当父接口中定义的变量被使用时,父接口才会被初始化.此外,接口的实现类再初始化是也一样不会执行接口的()方法.

• java虚拟机必须保证一个类的()方法在多线程环境中杯正确地加锁同步,如果多个线程同时去初始化一个类,那么只会有其中的一个线程去执行这个类的()方法,其他线程都需要阻塞等待,直到活动线程执行完毕(同一个类加载器下,一个类型只会被初始化一次).如果一个类的()方法中有耗时很长的操作,那就可能造成多个进程阻塞.

下面例子,用到的主要是初始化顺序这点

class Singleton{
    private static Singleton singleton = new Singleton();
    public static int value1;
    public static int value2 = 0;

    private Singleton(){
        value1++;
        value2++;
    }

    public static Singleton getInstance(){
        return singleton;
    }

}

class Singleton2{
    public static int value1;
    public static int value2 = 0;
    private static Singleton2 singleton2 = new Singleton2();

    private Singleton2(){
        value1++;
        value2++;
    }

    public static Singleton2 getInstance2(){
        return singleton2;
    }

}

public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println("Singleton1 value1:" + singleton.value1);
        System.out.println("Singleton1 value2:" + singleton.value2);

        Singleton2 singleton2 = Singleton2.getInstance2();
        System.out.println("Singleton2 value1:" + singleton2.value1);
        System.out.println("Singleton2 value2:" + singleton2.value2);
    }
    
    
    
    //运行结果:
Singleton1 value1:1
Singleton1 value2:0
Singleton2 value1:1
Singleton2 value2:1
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
47
48
49

​

2 singleton2 = Singleton2.getInstance2();
System.out.println(“Singleton2 value1:” + singleton2.value1);
System.out.println(“Singleton2 value2:” + singleton2.value2);
}

//运行结果:
1

Singleton1 value1:1
Singleton1 value2:0
Singleton2 value1:1
Singleton2 value2:1

​	



1
2
3
4
5
6
7
8
9