JVM系列(四) - JVM类加载机制详解
前言
本文将由浅及深，介绍Java类加载的过程和原理，进一步对类加载器的进行源码分析，完成一个自定义的类加载器。java
正文
(一). 类加载器是什么
类加载器简言之，就是用于把.class文件中的字节码信息转化为具体的java.lang.Class对象的过程的工具。编程
具体过程：后端
- 在实际类加载过程当中，
JVM会将全部的.class字节码文件中的二进制数据读入内存中，导入运行时数据区的方法区中。 - 当一个类首次被主动加载或被动加载时，类加载器会对此类执行类加载的流程 – 加载、链接（验证、准备、解析）、初始化。
- 若是类加载成功，堆内存中会产生一个新的
Class对象，Class对象封装了类在方法区内的数据结构。
Class对象的建立过程描述： 数组
(二). 类加载的过程
类加载的过程分为三个步骤(五个阶段) ：加载 -> 链接（验证、准备、解析）-> 初始化。缓存
加载、验证、准备和初始化这四个阶段发生的顺序是肯定的，而解析阶段能够在初始化阶段以后发生，也称为动态绑定或晚期绑定。数据结构
类加载的过程描述： 多线程
1. 加载
加载：查找并加载类的二进制数据的过程。架构
加载的过程描述：
- 经过类的全限定名定位
.class文件，并获取其二进制字节流。 - 把字节流所表明的静态存储结构转换为方法区的运行时数据结构。
- 在
Java堆中生成一个此类的java.lang.Class对象，做为方法区中这些数据的访问入口。
2. 链接
链接：包括验证、准备、解析三步。框架
a). 验证
验证：确保被加载的类的正确性。验证是链接阶段的第一步，用于确保Class字节流中的信息是否符合虚拟机的要求。异步
具体验证形式：
- 文件格式验证：验证字节流是否符合
Class文件格式的规范；例如：是否以0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围以内、常量池中的常量是否有不被支持的类型。 - 元数据验证：对字节码描述的信息进行语义分析（注意：对比
javac编译阶段的语义分析），以保证其描述的信息符合Java语言规范的要求；例如：这个类是否有父类，除了java.lang.Object以外。 - 字节码验证：经过数据流和控制流分析，肯定程序语义是合法的、符合逻辑的。
- 符号引用验证：确保解析动做能正确执行。
b). 准备
准备：为类的静态变量分配内存，并将其初始化为默认值。准备过程一般分配一个结构用来存储类信息，这个结构中包含了类中定义的成员变量，方法和接口信息等。
具体行为：
- 这时候进行内存分配的仅包括类变量(
static)，而不包括实例变量，实例变量会在对象实例化时随着对象一块分配在Java堆中。 - 这里所设置的初始值一般状况下是数据类型默认的零值（如
0、0L、null、false等），而不是被在Java代码中被显式赋值。
c). 解析
解析：把类中对常量池内的符号引用转换为直接引用。
解析动做主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符等7类符号引用进行。
3. 初始化
初始化：对类静态变量赋予正确的初始值 (注意和链接时的解析过程区分开)。
初始化的目标
- 实现对声明类静态变量时指定的初始值的初始化；
- 实现对使用静态代码块设置的初始值的初始化。
初始化的步骤
- 若是此类没被加载、链接，则先加载、链接此类；
- 若是此类的直接父类还未被初始化，则先初始化其直接父类；
- 若是类中有初始化语句，则按照顺序依次执行初始化语句。
初始化的时机
- 建立类的实例(
new关键字)； java.lang.reflect包中的方法(如：Class.forName(“xxx”))；- 对类的静态变量进行访问或赋值；
- 访问调用类的静态方法；
- 初始化一个类的子类，父类自己也会被初始化；
- 做为程序的启动入口，包含
main方法(如：SpringBoot入口类)。
(三). 类的主动引用和被动引用
主动引用
主动引用：在类加载阶段，只执行加载、链接操做，不执行初始化操做。
主动引用的几种形式
- 建立类的实例(
new关键字)； java.lang.reflect包中的方法(如：Class.forName(“xxx”))；- 对类的静态变量进行访问或赋值；
- 访问调用类的静态方法；
- 初始化一个类的子类，父类自己也会被初始化；
- 做为程序的启动入口，包含
main方法(如：SpringBoot入口类)。
主动引用1 - main方法在初始类中
代码示例：
public class OptimisticReference0 {
static {
System.out.println(OptimisticReference0.class.getSimpleName() + " is referred!");
}
public static void main(String[] args) {
System.out.println();
}
}
复制代码
运行结果：
OptimisticReference0 is referred!
主动引用2 – 建立子类会触发父类的初始化
代码示例：
public class OptimisticReference1 {
public static class Parent {
static {
System.out.println(Parent.class.getSimpleName() + " is referred!");
}
}
public static class Child extends Parent {
static {
System.out.println(Child.class.getSimpleName() + " is referred!");
}
}
public static void main(String[] args) {
new Child();
}
}
复制代码
运行结果：
Parent is referred! Child is referred!
主动引用3 – 访问一个类静态变量
代码示例：
public class OptimisticReference2 {
public static class Child {
protected static String name;
static {
System.out.println(Child.class.getSimpleName() + " is referred!");
name = "Child";
}
}
public static void main(String[] args) {
System.out.println(Child.name);
}
}
复制代码
运行结果：
Child is referred! Child
主动引用4 – 对类的静态变量进行赋值
代码示例：
public class OptimisticReference3 {
public static class Child {
protected static String name;
static {
System.out.println(Child.class.getSimpleName() + " is referred!");
}
}
public static void main(String[] args) {
Child.name = "Child";
}
}
复制代码
运行结果：
Child is referred!
主动引用5 – 使用java.lang.reflect包提供的反射机制
代码示例：
public class OptimisticReference4 {
public static void main(String[] args) throws ClassNotFoundException {
Class.forName("org.ostenant.jdk8.learning.examples.reference.optimistic.Child");
}
}
复制代码
运行结果：
Child is referred!
被动引用
被动引用： 在类加载阶段，会执行加载、链接和初始化操做。
被动引用的几种形式：
- 经过子类引用父类的的静态字段，不会致使子类初始化；
- 定义类的数组引用而不赋值，不会触发此类的初始化；
- 访问类定义的常量，不会触发此类的初始化。
被动引用1 – 子类引用父类的的静态字段，不会致使子类初始化
代码示例：
public class NegativeReference0 {
public static class Parent {
public static String name = "Parent";
static {
System.out.println(Parent.class.getSimpleName() + " is referred!");
}
}
public static class Child extends Parent {
static {
System.out.println(Child.class.getSimpleName() + " is referred!");
}
}
public static void main(String[] args) {
System.out.println(Child.name);
}
}
复制代码
运行结果：
Parent is referred! Parent
被动引用2 – 定义类的数组引用而不赋值，不会触发此类的初始化
代码示例：
public class NegativeReference1 {
public static class Child {
static {
System.out.println(Child.class.getSimpleName() + " is referred!");
}
}
public static void main(String[] args) {
Child[] childs = new Child[10];
}
}
复制代码
运行结果：
无输出
被动引用3 – 访问类定义的常量，不会触发此类的初始化
示例代码：
public class NegativeReference2 {
public static class Child {
public static final String name = "Child";
static {
System.out.println(Child.class.getSimpleName() + " is referred!");
}
}
public static void main(String[] args) {
System.out.println(Child.name);
}
}
复制代码
运行结果：
Child
(四). 三种类加载器
类加载器：类加载器负责加载程序中的类型（类和接口），并赋予惟一的名字予以标识。
类加载器的组织结构
类加载器的关系
Bootstrap Classloader是在Java虚拟机启动后初始化的。Bootstrap Classloader负责加载ExtClassLoader，而且将ExtClassLoader的父加载器设置为Bootstrap ClassloaderBootstrap Classloader加载完ExtClassLoader后，就会加载AppClassLoader，而且将AppClassLoader的父加载器指定为ExtClassLoader。
类加载器的做用
| Class Loader | 实现方式 | 具体实现类 | 负责加载的目标 |
|---|---|---|---|
| Bootstrap Loader | C++ | 由C++实现 | %JAVA_HOME%/jre/lib/rt.jar以及-Xbootclasspath参数指定的路径以及中的类库 |
| Extension ClassLoader | Java | sun.misc.Launcher$ExtClassLoader | %JAVA_HOME%/jre/lib/ext路径下以及java.ext.dirs系统变量指定的路径中类库 |
| Application ClassLoader | Java | sun.misc.Launcher$AppClassLoader | Classpath以及-classpath、-cp指定目录所指定的位置的类或者是jar文档，它也是Java程序默认的类加载器 |
类加载器的特色
- 层级结构：Java里的类装载器被组织成了有父子关系的层级结构。Bootstrap类装载器是全部装载器的父亲。
- 代理模式： 基于层级结构，类的代理能够在装载器之间进行代理。当装载器装载一个类时，首先会检查它在父装载器中是否进行了装载。若是上层装载器已经装载了这个类，这个类会被直接使用。反之，类装载器会请求装载这个类
- 可见性限制：一个子装载器能够查找父装载器中的类，可是一个父装载器不能查找子装载器里的类。
- 不容许卸载：类装载器能够装载一个类可是不能够卸载它，不过能够删除当前的类装载器，而后建立一个新的类装载器装载。
类加载器的隔离问题
每一个类装载器都有一个本身的命名空间用来保存已装载的类。当一个类装载器装载一个类时，它会经过保存在命名空间里的类全局限定名(Fully Qualified Class Name) 进行搜索来检测这个类是否已经被加载了。
JVM 及 Dalvik 对类惟一的识别是 ClassLoader id + PackageName + ClassName，因此一个运行程序中是有可能存在两个包名和类名彻底一致的类的。而且若是这两个类不是由一个 ClassLoader 加载，是没法将一个类的实例强转为另一个类的，这就是 ClassLoader 隔离性。
为了解决类加载器的隔离问题，JVM引入了双亲委托机制。
(五). 双亲委托机制
核心思想：其一，自底向上检查类是否已加载；其二，自顶向下尝试加载类。
具体加载过程
- 当
AppClassLoader加载一个class时，它首先不会本身去尝试加载这个类，而是把类加载请求委派给父类加载器ExtClassLoader去完成。 - 当
ExtClassLoader加载一个class时，它首先也不会本身去尝试加载这个类，而是把类加载请求委派给BootStrapClassLoader去完成。 - 若是
BootStrapClassLoader加载失败（例如在%JAVA_HOME%/jre/lib里未查找到该class），会使用ExtClassLoader来尝试加载； - 若是
ExtClassLoader也加载失败，则会使用AppClassLoader来加载，若是AppClassLoader也加载失败，则会报出异常ClassNotFoundException。
源码分析
ClassLoader.class
- loadClass()：经过指定类的全限定名称，由类加载器检测、装载、建立并返回该类的
java.lang.Class对象。
ClassLoader经过loadClass()方法实现了双亲委托机制，用于类的动态加载。
loadClass()自己是一个递归向上调用的过程。
-
自底向上检查类是否已加载
- 先经过
findLoadedClass()方法从最底端类加载器开始检查类是否已经加载。 - 若是已经加载，则根据
resolve参数决定是否要执行链接过程，并返回Class对象。 - 若是没有加载，则经过
parent.loadClass()委托其父类加载器执行相同的检查操做(默认不作链接处理)。 - 直到顶级类加载器，即
parent为空时，由findBootstrapClassOrNull()方法尝试到Bootstrap ClassLoader中检查目标类。
- 先经过
-
自顶向下尝试加载类
- 若是仍然没有找到目标类，则从
Bootstrap ClassLoader开始，经过findClass()方法尝试到对应的类目录下去加载目标类。 - 若是加载成功，则根据
resolve参数决定是否要执行链接过程，并返回Class对象。 - 若是加载失败，则由其子类加载器尝试加载，直到最底端类加载器也加载失败，最终抛出
ClassNotFoundException。
- 若是仍然没有找到目标类，则从
- findLoadedClass()
查找当前类加载器的缓存中是否已经加载目标类。
findLoadedClass()实际调用了底层的native方法findLoadedClass0()。
- findBootstrapClassOrNull()
查找最顶端
Bootstrap类加载器的是否已经加载目标类。一样，findBootstrapClassOrNull()实际调用了底层的native方法findBootstrapClass()。
- findClass()
ClassLoader是java.lang包下的抽象类，也是全部类加载器(除了Bootstrap)的基类，findClass()是ClassLoader对子类提供的加载目标类的抽象方法。注意：
Bootstrap ClassLoader并不属于JVM的层次，它不遵照ClassLoader的加载规则，Bootstrap classLoader并无子类。
- defineClass()
defineClass()是ClassLoader向子类提供的方法，它能够将.class文件的二进制数据转换为合法的java.lang.Class对象。
(六). 类的动态加载
类的几种加载方式
- 经过命令行启动时由
JVM初始化加载； - 经过
Class.forName()方法动态加载； - 经过
ClassLoader.loadClass()方法动态加载。
Class.forName()和ClassLoader.loadClass()
- Class.forName()：把类的
.class文件加载到JVM中，对类进行解释的同时执行类中的static静态代码块； - ClassLoader.loadClass()：只是把.class文件加载到
JVM中，不会执行static代码块中的内容，只有在newInstance才会去执行。
(七). 对象的初始化
对象的初始化顺序
静态变量/静态代码块 -> 普通代码块 -> 构造函数
- 父类静态变量和静态代码块（先声明的先执行）；
- 子类静态变量和静态代码块（先声明的先执行）；
- 父类普通成员变量和普通代码块（先声明的先执行）；
- 父类的构造函数；
- 子类普通成员变量和普通代码块（先声明的先执行）；
- 子类的构造函数。
对象的初始化示例
Parent.java
Children.java
Tester.java
测试结果：
测试结果代表：JVM在建立对象时，遵照以上对象的初始化顺序。
(八). 自定义类加载器
编写本身的类加载器
在源码分析阶段，咱们已经解读了如何实现自定义类加载器，如今咱们开始怼本身的类加载器。
Step 1：定义待加载的目标类
Parent.java和Children.java。
Parent.java
package org.ostenant.jdk8.learning.examples.classloader.custom;
public class Parent {
protected static String CLASS_NAME;
protected static String CLASS_LOADER_NAME;
protected String instanceID;
// 1.先执行静态变量和静态代码块（只在类加载期间执行一次）
static {
CLASS_NAME = Parent.class.getName();
CLASS_LOADER_NAME = Parent.class.getClassLoader().toString();
System.out.println("Step a: " + CLASS_NAME + " is loaded by " + CLASS_LOADER_NAME);
}
// 2.而后执行变量和普通代码块（每次建立实例都会执行）
{
instanceID = this.toString();
System.out.println("Step c: Parent instance is created: " + CLASS_LOADER_NAME + " -> " + instanceID);
}
// 3.而后执行构造方法
public Parent() {
System.out.println("Step d: Parent instance：" + instanceID + ", constructor is invoked");
}
public void say() {
System.out.println("My first class loader...");
}
}
复制代码
Children.java
package org.ostenant.jdk8.learning.examples.classloader.custom;
public class Children extends Parent {
static {
CLASS_NAME = Children.class.getName();
CLASS_LOADER_NAME = Children.class.getClassLoader().toString();
System.out.println("Step b: " + CLASS_NAME + " is loaded by " + CLASS_LOADER_NAME);
}
{
instanceID = this.toString();
System.out.println("Step e: Children instance is created: " + CLASS_LOADER_NAME + " -> " + instanceID);
}
public Children() {
System.out.println("Step f: Children instance：" + instanceID + ", constructor is invoked");
}
public void say() {
System.out.println("My first class loader...");
}
}
复制代码
Step 2：实现自定义类加载器
CustomClassLoader
CustomClassLoader.java
public class CustomClassLoader extends ClassLoader {
private String classPath;
public CustomClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
Class<?> c = findLoadedClass(name); // 可省略
if (c == null) {
byte[] data = loadClassData(name);
if (data == null) {
throw new ClassNotFoundException();
}
return defineClass(name, data, 0, data.length);
}
return null;
}
protected byte[] loadClassData(String name) {
try {
// package -> file folder
name = name.replace(".", "//");
FileInputStream fis = new FileInputStream(new File(classPath + "//" + name + ".class"));
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int len = -1;
byte[] b = new byte[2048];
while ((len = fis.read(b)) != -1) {
baos.write(b, 0, len);
}
fis.close();
return baos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
复制代码
Step 3：测试类加载器的加载过程
CustomerClassLoaderTester.java
- 测试程序启动时，逐一拷贝并加载待加载的目标类源文件。
private static final String CHILDREN_SOURCE_CODE_NAME = SOURCE_CODE_LOCATION + "Children.java";
private static final String PARENT_SOURCE_CODE_NAME = SOURCE_CODE_LOCATION + "Parent.java";
private static final List<String> SOURCE_CODE = Arrays.asList(CHILDREN_SOURCE_CODE_NAME, PARENT_SOURCE_CODE_NAME);
static {
SOURCE_CODE.stream().map(path -> new File(path))
// 路径转文件对象
.filter(f -> !f.isDirectory())
// 文件遍历
.forEach(f -> {
// 拷贝后源代码
File targetFile = copySourceFile(f);
// 编译源代码
compileSourceFile(targetFile);
});
}
复制代码
- 拷贝单一源文件到自定义类加载器的类加载目录。
protected static File copySourceFile(File f) {
BufferedReader reader = null;
BufferedWriter writer = null;
try {
reader = new BufferedReader(new FileReader(f));
// package ...;
String firstLine = reader.readLine();
StringTokenizer tokenizer = new StringTokenizer(firstLine, " ");
String packageName = "";
while (tokenizer.hasMoreElements()) {
String e = tokenizer.nextToken();
if (e.contains("package")) {
continue;
} else {
packageName = e.trim().substring(0, e.trim().length() - 1);
}
}
// package -> path
String packagePath = packageName.replace(".", "//");
// java file path
String targetFileLocation = TARGET_CODE_LOCALTION + "//" + packagePath + "//";
String sourceFilePath = f.getPath();
String fileName = sourceFilePath.substring(sourceFilePath.lastIndexOf("\\") + 1);
File targetFile = new File(targetFileLocation, fileName);
File targetFileLocationDir = new File(targetFileLocation);
if (!targetFileLocationDir.exists()) {
targetFileLocationDir.mkdirs();
}
// writer
writer = new BufferedWriter(new FileWriter(targetFile));
// 写入第一行
writer.write(firstLine);
writer.newLine();
writer.newLine();
String input = "";
while ((input = reader.readLine()) != null) {
writer.write(input);
writer.newLine();
}
return targetFile;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
reader.close();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
复制代码
- 对拷贝后的
.java源文件执行手动编译，在同级目录下生成.class文件。
protected static void compileSourceFile(File f) {
try {
JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager standardFileManager = javaCompiler.getStandardFileManager(null, null, null);
Iterable<? extends JavaFileObject> javaFileObjects = standardFileManager.getJavaFileObjects(f);
// 执行编译任务
CompilationTask task = javaCompiler.getTask(null, standardFileManager, null, null, null, javaFileObjects);
task.call();
standardFileManager.close();
} catch (Exception e) {
e.printStackTrace();
}
}
复制代码
- 经过自定义类加载器加载
Children的java.lang.Class<?>对象，而后用反射机制建立Children的实例对象。
@Test
public void test() throws Exception {
// 建立自定义类加载器
CustomClassLoader classLoader = new CustomClassLoader(TARGET_CODE_LOCALTION); // E://myclassloader//classpath
// 动态加载class文件到内存中（无链接）
Class<?> c = classLoader.loadClass("org.ostenant.jdk8.learning.examples.classloader.custom.Children");
// 经过反射拿到全部的方法
Method[] declaredMethods = c.getDeclaredMethods();
for (Method method : declaredMethods) {
if ("say".equals(method.getName())) {
// 经过反射拿到children对象
Object children = c.newInstance();
// 调用children的say()方法
method.invoke(children);
break;
}
}
}
复制代码
测试编写的类加载器
(一). 测试场景一
- 保留
static代码块，把目标类Children.java和Parent.java拷贝到类加载的目录，而后进行手动编译。 - 保留测试项目目录中的目标类
Children.java和Parent.java。
测试结果输出：
测试结果分析：
咱们成功建立了
Children对象，并经过反射调用了它的say()方法。 然而查看控制台日志，能够发现类加载使用的仍然是AppClassLoader，CustomClassLoader并无生效。
查看CustomClassLoader的类加载目录：
类目录下有咱们拷贝并编译的
Parent和Chidren文件。
分析缘由：
因为项目空间中的
Parent.java和Children.java，在拷贝后并无移除。致使AppClassLoader优先在其Classpath下面找到并成功加载了目标类。
(二). 测试场景二
- 注释掉
static代码块（类目录下有已编译的目标类.class文件）。 - 移除测试项目目录中的目标类
Children.java和Parent.java。
测试结果输出：
咱们成功经过自定义类加载器加载了目标类。建立了
Children对象，并经过反射调用了它的say()方法。
至此，咱们本身的一个简单的类加载器就完成了！
参考书籍
周志明，深刻理解Java虚拟机：JVM高级特性与最佳实践，机械工业出版社
欢迎关注技术公众号： 零壹技术栈
本账号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。
相关文章
- 1. 理解JVM（四）：JVM类加载机制
- 2. JVM系列(五) - JVM类加载机制详解
- 3. JVM总结（四）：JVM类加载机制
- 4. JVM类加载机制详解（一）JVM类加载过程
- 5. 【JVM】JVM类加载机制
- 6. JVM系列[2]-Java类加载机制
- 7. JVM系列-类加载机制
- 8. JVM 类加载机制详解
- 9. [JVM]深入类加载机制详解
- 10. JVM--详解类加载机制
- 更多相关文章...
- • ARP协议的工作机制详解 - TCP/IP教程
- • MySQL下载步骤详解 - MySQL教程
- • 漫谈MySQL的锁机制
- • Java Agent入门实战（三）-JVM Attach原理与使用
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 融合阿里云，牛客助您找到心仪好工作
- 2. 解决jdbc(jdbctemplate)在测试类时不报错在TomCatb部署后报错
- 3. 解决PyCharm GoLand IntelliJ 等 JetBrains 系列 IDE无法输入中文
- 4. vue+ant design中关于图片请求不显示的问题。
- 5. insufficient memory && Native memory allocation (malloc) failed
- 6. 解决IDEA用Maven创建的Web工程不能创建Java Class文件的问题
- 7. [已解决] Error: Cannot download ‘https://start.spring.io/starter.zip?
- 8. 在idea让java文件夹正常使用
- 9. Eclipse启动提示“subversive connector discovery”
- 10. 帅某-技巧-快速转帖博主文章（article_content）
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 理解JVM（四）：JVM类加载机制
- 2. JVM系列(五) - JVM类加载机制详解
- 3. JVM总结（四）：JVM类加载机制
- 4. JVM类加载机制详解（一）JVM类加载过程
- 5. 【JVM】JVM类加载机制
- 6. JVM系列[2]-Java类加载机制
- 7. JVM系列-类加载机制
- 8. JVM 类加载机制详解
- 9. [JVM]深入类加载机制详解
- 10. JVM--详解类加载机制