Java类加载机制（一）

猿究院Boss

已于 2023-09-11 23:18:16 修改

阅读量28

点赞数 1

文章标签： java 开发语言

于 2023-09-11 19:59:20 首次发布

本文链接：https://blog.csdn.net/2301_77661292/article/details/132815104

版权

1. 概述

类是在运行期间第一次使用时，被类加载器动态加载至JVM。JVM不会一次性加载所有类。因为如果一次性加载，那么会占用很多的内存。

2. 类的生命周期

类的生命周期包括：加载、验证、准备、解析、初始化、使用、卸载7个阶段。

2.1 类加载过程

类加载过程包含加载、验证、准备、解析、初始化五个阶段。

2.1.1 加载

加载过程完成以下3件事

$\bullet$ 通过类的完全限定名称获取定义该类的二进制字节流。

$\bullet$ 将该字节流表示的静态存储结构转换为Metaspace元空间区的运行时存储结构。

$\bullet$ 在内存中生成一个代表该类的Class对象，作为元空间区中该类各种数据的访问入口。

2.1.2 验证

$\bullet$ 确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

2.1.3 准备

为类变量分配内存并设置初始值，这些内存是在方法区中分配，但需要注意以下几点：

$\bullet$ 此处仅为类变量分配内存，而不包括实例变量，实例变量会随着对象实例化被分配在java堆中。

$\bullet$ 这里默认值是数据类型的默认值，而不是代码中被显示的赋予的值。

如下示例中，类变量value被初始化为 0 而不是 123。

    public static int value = 123;

$\bullet$ 如果类变量是常量（用final修饰），那么它将初始化为表达式所定义的值而不是 0。

如下示例中，常量 value被初始化为 123 而不是 0。

    public static final int value = 123;

2.1.4 解析

将常量池的符号引用替换为直接引用的过程。其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持Java的动态绑定。

2.1.5 初始化

为类的静态变量赋予正确的初始值，JVM负责对类进行初始化，主要对类变量进行初始化。初始化阶段是执行类构造器<clinit>()方法的过程。

$\bullet$ <client>()方法是由编译器自动收集类中的所有类变量赋值动作和静态语句static{}块中的语句合并产生的，编译器收集的顺序是由语句在源文件出现的顺序所决定的。静态语句块中只能访问到定义在静态语句块之前的变量，定义在之后的变量可以赋值，但不能访问。

$\bullet$ 接口与类不同的是，接口不需要先执行父类的<clinit>()方法，只有父接口定义的变量使用时，父接口才会被初始化。另外接口的实现类也不会先执行接口的<clinit>()方法。

$\bullet$ 虚拟机保证当多线程去初始化类时，只会有一个线程去执行<clinit>方法，而其他线程则被阻塞。

3. 类加载时机

3.1 主动加载

虚拟机规范中并没有强制约束何时进行加载，但是规范严格规定了只有下列六种情况必须对类进行加载：

$\bullet$ 当遇到 new、getstatic、putstatic 或 invokestatic 这 4 条字节码指令时，比如new一个对象，读取一个静态字段(未被 final 修饰)、或调用一个类的静态方法时。

$\circ$ 当jvm执行new指令时会加载类。即：当程序创建一个类的实例对象。

public class Demo01 {
	
	public static void main(String[] args) {
		//new指令
		Parent p = new Parent();//parent类被加载！
	}
	
}

class Parent{
	static int A = 23;
	static {
		System.out.println("parent类被加载！");
	}
	
	static void dosth() {}
}

$\circ$ 当jvm执行 getstatic指令时会加载类。即：程序访问类的静态变量(不是静态常量，常量会被加载到运行时常量池)。

public class Demo01 {
	
	public static void main(String[] args) {
		//getstatic指令
		System.out.println(Parent.A);//parent类被加载！
	}
	
}

class Parent{
	static int A = 23;
	static {
		System.out.println("parent类被加载！");
	}
	
	static void dosth() {}
}

$\circ$ 当jvm执行 putstatic指令时会加载类。即：程序给类的静态变量赋值。

public class Demo01 {
	
	public static void main(String[] args) {
	    //putstatic指令
		Parent.A=1000;//parent类被加载！
	}
	
}

class Parent{
	static int A = 23;
	static {
		System.out.println("parent类被加载！");
	}
	
	static void dosth() {}
}

$\circ$ 当jvm执行 invokestatic指令时会加载类。即：程序调用类的静态方法。

public class Demo01 {
	
	public static void main(String[] args) {
		//invokestatic指令
		Parent.dosth();//parent类被加载！
	}
	
}

class Parent{
	static int A = 23;
	static {
		System.out.println("parent类被加载！");
	}
	
	static void dosth() {}
}

$\bullet$ 使用 java.lang.reflect 包的方法对类进行反射调用时如Class.forname("..."), 或newInstance() 等等。如果类没初始化，需要触发类的加载。

public class Demo01 {
	
	public static void main(String[] args) {
		try {
			Class.forName("com.apesource.Parent");//parent类被加载！
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

-------------------或-----------------------

        //仅获取类的class对象不会加载
		//使用newInstance(),会触发类加载
		try {
			Class cls = Parent.class;
			cls.newInstance();//parent类被加载！
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

class Parent{
	static int A = 23;
	static {
		System.out.println("parent类被加载！");
	}
	
	static void dosth() {}
}

$\bullet$ 加载一个类，如果其父类还未加载，则先触发该父类的加载。

$\bullet$ 当虚拟机启动时，用户需要定义一个要执行的主类 (包含 main() 方法的类)，虚拟机会先加载这个类。

public class Demo01 {
	static {
		System.out.println("Demo01被加载！");
	}
	public static void main(String[] args) {
		//parent类被加载！
	}
	
}

class Parent{
	static int A = 23;
	static {
		System.out.println("parent类被加载！");
	}
	
	static void dosth() {}
}

$\bullet$ 当一个接口中定义了 JDK8 新加入的默认方法（被default 关键字修饰的接口方法）时，如果有这个接口的实现类发生了加载，则该接口要在实现类之前被加载。

3.2 被动引用

除主动引用之外，所有引用类的方式都不会触发加载，称为被动引用。

$\bullet$ 通过子类引用父类的静态字段，不会导致子类加载。

public class Demo02 {
	public static void main(String[] args) {
		//累不会被加载
		System.out.println(Son.A);
	}

}

class Parent{
	static int A = 23;
	static {
		System.out.println("parent类被加载！");
	}
	
	static void dosth() {}
}

class Son extends Parent{
	static {
		System.out.println("Son类被加载！");
	}
	
}

$\bullet$ 通过数组定义来引用类，不会触发此类的加载。该过程会对数组类进行加载，数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类，其中包含了数组的属性和方法。

public class Demo02 {
	public static void main(String[] args) {
		//累不会被加载
		//
		Parent[] p = new Parent[16];
		
	}

}

class Parent{
	static int A = 23;
	static {
		System.out.println("parent类被加载！");
	}
	
	static void dosth() {}
}

class Son extends Parent{
	static {
		System.out.println("Son类被加载！");
	}
	
}

$\bullet$ 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的加载。

下一篇：Java类加载机制（二）