一、JVM和类

当我们调用Java命令运行某个Java程序时，该命令将启动一个Java虚拟机进程，不管该Java程序有多么复杂，该程序启动了多少个线程，它们都处于该Java虚拟机进程里。同一个JVM的所有线程、所有变量都处于同一个进程里，它们都使用该JVM进程的内存区。

由于Java的跨平台性，经过编译的Java源程序并不是一个可执行程序，而是一个或多个类文件。当Java程序需要使用某个类时，如果该类还未被加载到内存中，Java虚拟机会通过类加载器将这个类对象加载进入内存。

类加载的特性：
在JVM的生命周期里，每个类只会被加载一次。

类加载的原则：
延迟加载，能少加载就少加载，因为虚拟机的空间是有限的。

类加载的时机：
关于类什么时候被加载，Java虚拟机规范并没有做出硬性的规定，不同JVM可能有不同的实现，一般分为下面两种情况：

  • 饿汉式：只要有其他类引用了它就加载
  • 懒汉式：类初始化的时候才加载

一般来说，在这些情况下会加载类：

  • 第一次创建对象要加载类
  • 调用静态方法，访问静态属性时会加载类
  • 加载子类时必定会先加载父类
  • 子类调用父类的静态方法时：如果子类没有覆盖父类的静态方法，那么只加载父类，不加载子类；如果子类有覆盖父类的静态方法，那么即加载父类，又加载子类
  • 访问静态常量时，如果编译器可以计算出常量的值，则不会加载类，例如:public static final int a =123;否则会加载类,例如:public static final int a = math.PI。

二、类的加载器与类的“相同”判断

2.1 类的加载过程

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用和卸载七个阶段。其中，准备、验证、解析三个部分统称为链接。如图所示：

java 怎么实现只加载多个同名类中的一个 java 类只能加载一次_加载


加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定（也称为动态绑定或者晚期绑定）。后续介绍的关于类的加载的具体内容都以HotSpot为基准。

2.2 类加载器与类的“相同”判断

类加载器除了用于加载类外，还可用于确定类在Java虚拟机中的唯一性。

即便是相同的字节代码，被不同的类加载器加载之后所得到的类，也是不同的。

通俗一点来讲，要判断两个类是否“相同”，前提是这两个类必须被同一个类加载器加载，否则这两个类不“相同”。

这里指的“相同”，包括类的class对象的equals()方法，isAssignableFrom()方法，isInstance()方法，instanceof关键字等判断出来的结果。

三、类初始化的时机

在类和接口被加载和连接的时机上, Java虚拟机规范给实现提供了一定的灵活性 。但是它严格地定义了初始化的时机 。所有的Java虚拟机实现必须在每个类或接口首次主动使用时初始化 。下面这几种情形必须立即对类进行“初始化”：

  1. 遇到 new、 getstatic、 putstatic或invokestatic这4条字节码指令时,如果类没有进行过初始化, 则需要先触发其初始化, 生成这4条指令的最常见的 Java代码场景是:
    (1) 使用 new关键字实例化对象的时候
    (2)读取或设置一个类的静态字段的时候(即在字节码中,执行getstalic或putstatic指令时),被final修饰、已在编译期把结果放入常量池的静态字段除外
    (3)调用一个类的静态方法的时候(即在字节码中执行invokestatic指令时)。
  2. 当调用Java API中的某些反射方法时, 比如类Class中的方法或者java.lang.reflect包的方法对类进行反射调用的时候, 如果类没有进行过初始化 , 则需要先触发其初始化。
  3. 当初始化一个类的时候, 如果发现其父类还没有进行过初始化, 则需要先触发其父类的初始化。
  4. 当虚拟机启动时, 用户需要指定一个要执行的主类(包合 main()方法的那个类) . 虚拟机会先初始化这个主类。
  5. 当使用JDK1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果是REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。

对于这五种会触发类进行初始化的场景, 虚拟机规范中使用了一个很强烈的限定语:“有且只有 ‘’, 这5种场景中的行为称为对一个类进行主动引用 。 除此之外，所有引用类的方式都不会触发初始化, 称为被动引用。

四、加载过程

4.1 加载

加载是类加载过程的一个阶段，这两个概念一定不要混淆。在加载阶段（可以参考java.lang.ClassLoader的loadClass()方法）, 虚拟机需要完成以下三件事情:

  1. 通过一个类的全限定名来获取定义此类的二进制字节流（并没有指明要从一个Class文件中获取，可以从其他渠道，譬如：网络、动态生成、数据库等）。
  2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。（hotspot选择将class对象存储在方法区中，Java虚拟机规范并没有明确要求一定要存储在方法区或堆区中）
  3. 将类的class文件读入内存，并为之创建一个java.lang.Class对象，也就是说当程序中使用任何类时，系统都会为之建立一个java.lang.Class对象, 作为方法区这个类的各种数据的访问入口。

通过使用不同的类加载器，可以从不同来源加载类的二进制数据，通常有如下几种来源：

  • 从本地文件系统加载class文件；
  • 从一个ZIP、 JAR、 CAB或者其他某种归档文件中提取Java class文件，JDBC编程时使用到的数据库驱动就是放在JAR文件中，JVM可以直接从JAR包中加载class文件；
  • 通过网络加载class文件，这种场景最典型的应用就是 Applet；
  • 把一个java源文件动态编译、并执行加载
  • 运行时计算生成, 这种场景使用得最多的就是动态代理技术, 在 java.lang.reflect.Proxy中 , 就是用了 ProxyGenerator.generateProxyClass来为特定接口生成形式为“*$Proxy”的代理类的二进制字节流。

注意加载阶段和链接阶段的部分内容（如一部分字节码文件格式验证动作）是交叉进行的，加载阶段尚未完成，链接阶段可能已经开始，但这些夹在加载阶段之中进行的动作，仍然属于链接阶段的内容，这两个阶段的开始时间仍然保持着固定的先后顺序。

4.2 类的链接

当类被加载后，系统为之生成一个对应的Class对象，接着会进入连接阶段，连接阶段将会负责把类的二进制文件合并到JRE中。类连接分为如下三个阶段：

  • 验证：验证阶段用于检验被加载的类是否有正确的内部结构，并和其他类协调一致。主要包括四个检验过程：文件格式验证、元数据验证、字节码验证和符号引用验证
  • 准备：准备阶段则负责为类的静态属性分配内存，并设置默认初始值（由于还没有产生对象，实例变量将不在此操作范围内）
  • 解析：将类的二进制数据中的符号引用替换成直接引用（符号引用是用一组符号描述所引用的目标；直接引用是指向目标的指针），得到类或字段、方法在内存中的指针或者偏移量，以便直接调用该方法）。这个阶段可以在初始化之后再执行。

4.2.1 验证

验证是连接阶段的第一步, 这一阶段的目的是为了确保 Class文件的字节流中包含的信息符合当前虚拟机的要求, 井且不会危害虚拟机自身的安全。

Java语言本身是相对安全的语言，但前面已经说过, Class文件并不一定要求用 Java源码编译而来, 可以使用任何途径, 包括用十六进制编译器直接编写来产生 Class 文件。在字节码的语言层面上, 上述 Java代码无法做到的事情都是可以实现的, 至少语义上是可以表达出来的。虚拟机如果不检査输入的字节流,对其完全信任的话, 很可能会因为载入了有害的字节流而导致系统崩溃 , 所以验证是虚拟机对自身保护的一项重要工作。从整体上看，验证阶段会完成下面四个阶段的检验过程: 文件格式验证、 元数据验证、 字节码验证、符号引用验证。

  • 文件格式验证：验证字节流是否符合Class文件格式的规范；例如：是否以魔术0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型。
  • 元数据验证：对字节码描述的信息进行语义分析（注意：对比javac编译阶段的语义分析），以保证其描述的信息符合Java语言规范的要求；例如：这个类是否有父类，除了java.lang.Object之外。
  • 字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。
  • 符号引用验证：确保解析动作能正确执行。

验证阶段是非常重要的，但不是必须的，它对程序运行期没有影响，如果所引用的类经过反复验证，那么可以考虑采用-Xverifynone参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

4.2.2 准备

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配 。这个阶段中有两个容易产生混淆的概念需要强调一下, 首先，这时候进行内存分配的仅包括类变量(被static修饰的变量)，而不包括实例变量,实例变量将会在对象实例化时随着对象一起分配在 Java 堆中 。 其次，这里所说的初始值“通常情况”下是数据类型的零值。假设一个类变量的定义为：

public static int value=123;

那变量value在准备阶段过后的初始值为0而不是123.因为这时候尚未开始执行任何java方法，而把value赋值为123的putstatic指令是程序被编译后，存放于类构造器()方法之中，所以把value赋值为123的动作将在初始化阶段才会执行。

至于“特殊情况”是指：public static final int value=123，即当类字段的字段属性是ConstantValue时，会在准备阶段初始化为指定的值，所以标注为final之后，value的值在准备阶段初始化为123而非0.

4.2.3 解析

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程， 解新动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行,分别对应于常量池的CONSTANT_Class_info、 CONSTANT_Fieldref_info、CONSTANT_Methodref_info、CONSTANT_IntrfaceMethodref_info、CONSTANT_MethodType_info、CONSTANT_MethodHandle_info和CONSTANT_InvokeDynamic_info7种常量类型,解析阶段中所说的直接引用与符号引用关系如下：

  • 符号引用(Symlxiuc References):符号引用以一组符号来描述所引用的日标,符号可以是任何形式的字面量, 只要使用时能无歧义地定位到目标即可, 特号引用与配組机实现的内存1布.局11i-美 , 引用的日标并不一定已组加裁到内存中
  • 直接引用(Direct References):直接引用可以是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。直接引用是与虚拟机实现的内存布局相关的 , 同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同. 如果有了直接引用, 那引用的目标必定已经在内存中存在
4.2.3.1 符号引用与直接引用

符号引用以一组符号来描述所引用的目标。符号引用可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可，符号引用和虚拟机的布局无关。个人理解为：在编译的时候一个每个java类都会被编译成一个class文件，但在编译的时候虚拟机并不知道所引用类的地址，多以就用符号引用来代替，而在这个解析阶段就是为了把这个符号引用转化成为真正的地址的阶段。

java代码

public class Test{

   public static void main() {
     String s=”adc”;

     System.out.println(“s=”+s);

   }

}

字节码：

public class Test {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main();
    Code:
       0: ldc           #2                  // String adc
       2: astore_0
       3: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       6: new           #4                  // class java/lang/StringBuilder
       9: dup
      10: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
      13: ldc           #6                  // String s=
      15: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      18: aload_0
      19: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      22: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      25: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      28: return
}

这个代码中在编译的时候对应的s会被解析成为符号引用。

对比java代码：

public class Test{

   public static void main() {

     System.out.println(“s=”+”abc”);

   }

}

相应的字节码：

Compiled from "Test.java"
public class Test {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main();
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String s=abc
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

4.3 类的初始化

初始化阶段是类加载过程的最后一步 , 前面的几个阶段, 除了在加载阶段用户应用程序可以通过自定义类加载器參与之外, 其余动作完全由虚拟机主导和控制。在连接的准备阶段，类变量已赋过一次系统要求的初始值，到了初始化阶段, 才真正开始执行类中定义的 Java程序代码。

举个例子如下：

public static int value1  = 5;
    public static int value2  = 6;
    static{
        value2 = 66;
    }

在准备阶段value1和value2都等于0
在初始化阶段value1和value2分别等于5和6

从代码角度，初始化阶段是执行类构造器< clinit >()方法的过程。

  • 所有类变量初始化语句和静态代码块都会在编译时被前端编译器放在收集器里头，存放到一个特殊的方法中，这个方法就是< clinit >方法，即类/接口初始化方法，该方法只能在类加载的过程中由JVM调用
  • 编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块中只能访问到定义在静态语句块之前的变量
  • 如果超类还没有被初始化，那么优先对超类初始化，但在< clinit >方法内部不会显示调用超类的< clinit >方法，由JVM负责保证一个类的< clinit >方法执行之前，它的超类< clinit >方法已经被执行。
  • JVM必须确保一个类在初始化的过程中，如果是多线程需要同时初始化它，仅仅只能允许其中一个线程对其执行初始化操作，其余线程必须等待，只有在活动线程执行完对类的初始化操作之后，才会通知正在等待的其他线程（所以可以利用静态内部类实现线程安全的单例模式）
  • 如果一个类没有声明任何的类变量，也没有静态代码块，那么可以没有类< clinit >方法

类的初始化阶段主要是对类变量进行初始化，在Java类中对类变量指定初始值有两种方式：

  1. 声明类变量时指定初始值
  2. 使用静态初始化块为类变量指定初始值

JVM初始化一个类一般包括如下几个步骤：

  1. 假如这个类还没有被加载和连接，程序先加载并连接该类；
  2. 假如该类的直接父类还没有被初始化，则先初始化其直接父类；
  3. 假如类中有初始化语句，则系统依次执行这些初始化语句

当执行第二步时，系统对直接父类的初始化也遵循此1、2、3步骤，如果该直接父类又有直接父类，系统再次重复这三步，所以JVM最先初始化的总是java.lang.Object类。

何时触发初始化：

  • 为一个类创建一个新的对象实例时（比如new、反射、序列化）
  • 调用一个类型的静态方法时（即在字节码中执行invokestatic指令）
  • 调用一个类型或接口的静态字段，或者对这些静态字段执行赋值操作时（即在字节码中，执行getstatic或者putstatic指令），不过用final修饰的静态字段除外，它被初始化为一个编译时常量表达式
  • 调用JAVA API中的反射方法时（比如调用java.lang.Class中的方法，或者java.lang.reflect包中其他类的方法）
  • 初始化一个类的派生类时（Java虚拟机规范明确要求初始化一个类时，它的超类必须提前完成初始化操作，接口例外）
  • JVM启动包含main方法的启动类时。

五、类的卸载

JVM中的class只有满足以下三个条件，才能被GC回收，也就是该class被卸载：

  • 该类所有的实例都已经被GC，也就是JVM中不存在该类的任何实例
  • 加载该类的classloader已经被GC
  • 该类的java.lang.Class 对象没有在任何地方被引用，如不能在任何地方通过反射访问该类的方法