文章目录提示：本文在编写的时候，思路借鉴了一个博主对这块的理解，原博主博客地址——https://imlql.cn/，加以我的理解和对书和视频的学习，文章思路也是借鉴了宋老师的视频讲解顺序，另外对《深入理解java虚拟机》这本书也是把重点的地方进行了搬运，可以说是很全了，秉承着开源精神和极客精神写了这篇博文，希望读者能够动动尊贵的手指关注、点赞（哥，别老白嫖，总结很辛苦的，拜托了）。
先上个图，下图是JVM内存结构图，今天学第一部分——类加载器子系统
为什么number输出为10？
1、链接阶段：类加载是在（linking）链接的（prepare）准备阶段会“为类变量分配内存并设置该类变量的默认初始值”。此时number会赋值为0；
2、初始阶段：执行< init>()（类的初始化方法）会执行类变量和静态代码块的的赋值动作，此时number先赋值为20再赋值为10
3、所以最后输出为10
但是如果在static中打印number，就会报错:非法的前向引用，因为number这个变量的声明在 static代码块的下面
main中有两个线程t1、t2，这两个线程都去创建DeadThread对象，最终while中的方法只打印一次。
原因：【虚拟机必须保证一个类的< clinit>()方法在多线程下被同步加锁】，DeadThread只会加载一次，t2线程在加载该类执行< clinit>()类初始化方法时，该类的静态代码块是死循环，因此有< clinit>()同步锁，所以就出现如下结果。
结果：
案例：
public class ClassLoaderTest {
public static void main(String[] args) {
//获取系统类加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
//获取其上层：扩展类加载器
ClassLoader extClassLoader = systemClassLoader.getParent();
System.out.println(extClassLoader);//sun.misc.Launcher$ExtClassLoader@1540e19d
//获取其上层：获取不到引导类加载器
ClassLoader bootstrapClassLoader = extClassLoader.getParent();
System.out.println(bootstrapClassLoader);//null
//对于用户自定义类来说：默认使用系统类加载器进行加载
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
//String类使用引导类加载器进行加载的。---> Java的核心类库都是使用引导类加载器进行加载的。
ClassLoader classLoader1 = String.class.getClassLoader();
System.out.println(classLoader1);//null
}
}
3.1 引导类加载器（Bootstrap ClassLoader）
- 对于用户自定义的类来说，默认使用系统类加载器
- java的核心类库都是由引导类加载器加载的
- 可以通过getParent()方法获取上一级类加载器，再重申一遍，加载器之间是包含关系，不是继承关系
- 引导类加载器 Bootstrap Class Loader 因为是c语言写的，所以获取不到，它负责加载java核心类库，包括扩展类加载器和系统类加载器
public class ClassLoaderTest1 {
public static void main(String[] args) {
System.out.println("**********启动类加载器**************");
//获取BootstrapClassLoader能够加载的api的路径
URL[] urLs = sun.misc.Launcher.getBootstrapClassPath().getURLs();
for (URL element : urLs) {
System.out.println(element.toExternalForm());
}
//从上面的路径中随意选择一个类,来看看他的类加载器是什么:引导类加载器
ClassLoader classLoader = Provider.class.getClassLoader();
System.out.println(classLoader);
System.out.println("***********扩展类加载器*************");
String extDirs = System.getProperty("java.ext.dirs");
for (String path : extDirs.split(";")) {
System.out.println(path);
}
//从上面的路径中随意选择一个类,来看看他的类加载器是什么:扩展类加载器
ClassLoader classLoader1 = CurveDB.class.getClassLoader();
System.out.println(classLoader1);//sun.misc.Launcher$ExtClassLoader@1540e19d
}
}
3.4 用户自定义类加载器
在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的，在必要时，我们还可以自定义类加载器，来定制类的加载方式。
为什么自定义类加载器？
用户自定义类加载器实现步骤：
public class CustomClassLoader extends ClassLoader {
@Override
protected Class findClass(String name) throws ClassNotFoundException {
try {
byte[] result = getClassFromCustomPath(name);
if (result == null) {
throw new FileNotFoundException();
} else {
//defineClass和findClass搭配使用
return defineClass(name, result, 0, result.length);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
throw new ClassNotFoundException(name);
}
//自定义流的获取方式
private byte[] getClassFromCustomPath(String name) {
//从自定义路径中加载指定类:细节略
//如果指定路径的字节码文件进行了加密，则需要在此方法中进行解密操作。
return null;
}
public static void main(String[] args) {
CustomClassLoader customClassLoader = new CustomClassLoader();
try {
Class clazz = Class.forName("One", true, customClassLoader);
Object obj = clazz.newInstance();
System.out.println(obj.getClass().getClassLoader());
} catch (Exception e) {
e.printStackTrace();
}
}
}
3.5 关于ClassLoader
ClassLoader类，它是一个抽象类，其后所有的类加载器都继承自ClassLoader（不包括启动类加载器）
获取ClassLoader的途径：
public class ClassLoaderTest2 {
public static void main(String[] args) {
try {
//1.
ClassLoader classLoader = Class.forName("java.lang.String").getClassLoader();
System.out.println(classLoader);
//2.
ClassLoader classLoader1 = Thread.currentThread().getContextClassLoader();
System.out.println(classLoader1);
//3.
ClassLoader classLoader2 = ClassLoader.getSystemClassLoader().getParent();
System.out.println(classLoader2);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
四、双亲委派机制
Java虚拟机对class文件采用的是按需加载的方式，也就是说当需要到该类时才会将它的class文件加载到内存生成class对象。而且加载某个类的class文件时，java虚拟机采用的是双亲委派机制，即把请求交由父类处理，它是一种任务委派机制。
4.1 工作原理1）如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行。
2）如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器。
3）如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式。
这个是自定义的String类，放在自定义包java.lang下：
public class String {
//
static{
System.out.println("我是自定义的String类的静态代码块");
}
}
测试一下，
public class StringTest {
public static void main(String[] args) {
java.lang.String str = new java.lang.String();
System.out.println("hello,atguigu.com");
StringTest test = new StringTest();
System.out.println(test.getClass().getClassLoader());
}
}
测试结果：并没有打印我们自定义的java.lang.String中的静态代码块。。。说明我们当前的String还是核心api里的，如果是我们自定义的话，那项目里的其他String都出问题了。
再在自定义的String里写个main方法，执行后发现抱错
package java.lang;
public class String {
//
static{
System.out.println("我是自定义的String类的静态代码块");
}
public static void main(String[] args) {
System.out.println("hello,String");
}
}
java.lang.String根据双亲委派机制，依次向上委托，它是由引导类加载器加载的（Bootstrap ClassLoader启动类加载器只加载包名为java、javax、sun等开头的类），在调用main时，因为我们的String加载的是核心api的，它是没有main方法的，所以报错。
4.1.1 案例24.2 双亲委派机制的优势SPI核心接口由引导类加载器来加载，SPI具体实现类由系统类加载器来加载
自定义String类，但是在加载自定义String类时会率先使用引导类加载器加载，而引导类加载器加载会先加载jdk自带的文件（rt.jar包中java/lang/String.class），报错信息没有main方法就是因为加载的是rt.jar包中的String类。这样就可以保证java核心源码的保护，这就是沙箱安全机制。
六、类的主动使用和被动使用JVM中表示两个class对象是否为同一个类存在两个必要条件：
换句话说，在JVM中，即使这两个类对象（class对象）来源同一个Class文件，被同一个虚拟机所加载，但只要加载它们的ClassLoader实例对象不同，那么这两个类对象也是不相等的。
举例：我们自定义的String虽然全类名也是java.lang.String，和核心api的String一样。但是却不是同一个类加载器，所以不是同一个类。
JVM必须知道一个类是由启动类加载器加载的还是由用户类加载器加载的。如果一个类型是由用户类加载器加载的，那么JVM会将这个类加载器的一个引用作为类型信息的一部分放在方法区中。当解析一个类型到另一个类型的引用时，JVM需要保证这两个类的加载器是相同的。
提示：本文在编写的时候，思路借鉴了一个博主对这块的理解，原博主博客地址——https://imlql.cn/，加以我的理解和对书和视频的学习，文章思路也是借鉴了宋老师的视频讲解顺序，另外对《深入理解java虚拟机》这本书也是把重点的地方进行了搬运，可以说是很全了，秉承着开源精神和极客精神写了这篇博文，希望读者能够动动尊贵的手指关注、点赞（哥，别老白嫖，总结很辛苦的，拜托了）。。。。。。。
