类加载流程，类加载机制及自定义类加载器详解（面试不再怕了）
1、引言2、类的加载、连接、初始化一、加载1.一、加载的class来源二、类的连接2.一、验证2.二、准备2.三、解析三、类的初始化3.一、< clinit>方法相关3.二、类初始化时机3.三、final定义的初始化3.四、ClassLoader只会对类进行加载，不会进行初始化3、类加载器一、JVM类加载器分类1.一、Bootstrap ClassLoader1.2 、Extension ClassLoader1.三、 System ClassLoader4、类加载机制1.一、JVM主要的类加载机制。1.二、类加载流程图5、建立并使用自定义类加载器一、自定义类加载分析二、实现自定义类加载器6、总结java
1、引言
当程序使用某个类时，若是该类还未被加载到内存中，则JVM会经过加载、连接、初始化三个步骤对该类进行类加载。bootstrap
2、类的加载、连接、初始化
一、加载
类加载指的是将类的class文件读入内存，并为之建立一个java.lang.Class对象。类的加载过程是由类加载器来完成，类加载器由JVM提供。咱们开发人员也能够经过继承ClassLoader来实现本身的类加载器。数组
1.一、加载的class来源
- 从本地文件系统内加载class文件
- 从JAR包加载class文件
- 经过网络加载class文件
- 把一个java源文件动态编译，并执行加载。
二、类的连接
经过类的加载，内存中已经建立了一个Class对象。连接负责将二进制数据合并到 JRE中。连接须要经过验证、准备、解析三个阶段。缓存
2.一、验证
验证阶段用于检查被加载的类是否有正确的内部结构，并和其余类协调一致。便是否知足java虚拟机的约束。安全
2.二、准备
类准备阶段负责为类的类变量分配内存，并设置默认初始值。网络
2.三、解析
咱们知道，引用其实对应于内存地址。思考这样一个问题，在编写代码时，使用引用，方法时，类知道这些引用方法的内存地址吗？显然是不知道的，由于类还未被加载到虚拟机中，你没法得到这些地址。举例来讲，对于一个方法的调用，编译器会生成一个包含目标方法所在的类、目标方法名、接收参数类型以及返回值类型的符号引用，来指代要调用的方法。多线程
解析阶段的目的，就是将这些符号引用解析为实际引用。若是符号引用指向一个未被加载的类，或者未被加载类的字段或方法，那么解析将触发这个类的加载（但未必会触发解析与初始化）。app
三、类的初始化
类的初始化阶段，虚拟机主要对类变量进行初始化。虚拟机调用< clinit>方法，进行类变量的初始化。jvm
java类中对类变量进行初始化的两种方式：ide
- 在定义时初始化
- 在静态初始化块内初始化
3.一、< clinit>方法相关
- 虚拟机会收集类及父类中的类变量及类方法组合为< clinit>方法，根据定义的顺序进行初始化。虚拟机会保证子类的< clinit>执行以前，父类的< clinit>方法先执行完毕。所以，虚拟机中第一个被执行完毕的< clinit>方法确定是java.lang.Object方法。
public class Test {
static int A = 10;
static {
A = 20;
}
}
class Test1 extends Test {
private static int B = A;
public static void main(String[] args) {
System.out.println(Test1.B);
}
}
//输出结果
//20
从输出中看出，父类的静态初始化块在子类静态变量初始化以前初始化完毕，因此输出结果是20，不是10。
若是类或者父类中都没有静态变量及方法，虚拟机不会为其生成< clinit>方法。
接口与类不一样的是，执行接口的＜clinit＞方法不须要先执行父接口的＜clinit＞方法。 只有当父接口中定义的变量使用时，父接口才会初始化。 另外，接口的实现类在初始化时也同样不会执行接口的＜clinit＞方法。
public interface InterfaceInitTest {
long A = CurrentTime.getTime();
}
interface InterfaceInitTest1 extends InterfaceInitTest {
int B = 100;
}
class InterfaceInitTestImpl implements InterfaceInitTest1 {
public static void main(String[] args) {
System.out.println(InterfaceInitTestImpl.B);
System.out.println("---------------------------");
System.out.println("当前时间："+InterfaceInitTestImpl.A);
}
}
class CurrentTime {
static long getTime() {
System.out.println("加载了InterfaceInitTest接口");
return System.currentTimeMillis();
}
}
//输出结果
//100
//---------------------------
//加载了InterfaceInitTest接口
//当前时间：1560158880660
从输出验证了：对于接口，只有真正使用父接口的类变量才会真正的加载父接口。这跟普通类加载不同。
- 虚拟机会保证一个类的< clinit>方法在多线程环境中被正确地加锁和同步，若是多个线程同时去初始化一个类，那么只有一个线程去执行这个类的< clinit>方法，其余线程都须要阻塞等待，直到活动线程执行< clinit>方法完毕。
public class MultiThreadInitTest {
static int A = 10;
static {
System.out.println(Thread.currentThread()+"init MultiThreadInitTest");
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Runnable runnable = () -> {
System.out.println(Thread.currentThread() + "start");
System.out.println(MultiThreadInitTest.A);
System.out.println(Thread.currentThread() + "run over");
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
thread1.start();
thread2.start();
}
}
//输出结果
//Thread[main,5,main]init MultiThreadInitTest
//Thread[Thread-0,5,main]start
//10
//Thread[Thread-0,5,main]run over
//Thread[Thread-1,5,main]start
//10
//Thread[Thread-1,5,main]run over
从输出中看出验证了：只有第一个线程对MultiThreadInitTest进行了一次初始化，第二个线程一直阻塞等待等第一个线程初始化完毕。
3.二、类初始化时机
- 当虚拟机启动时，初始化用户指定的主类；
- 当遇到用以新建目标类实例的new指令时，初始化new指令的目标类；
- 当遇到调用静态方法或者使用静态变量，初始化静态变量或方法所在的类；
- 子类初始化过程会触发父类初始化；
- 若是一个接口定义了default方法，那么直接实现或者间接实现该接口的类的初始化，会触发该接口初始化；
- 使用反射API对某个类进行反射调用时，初始化这个类；
- Class.forName()会触发类的初始化
3.三、final定义的初始化
注意：对于一个使用final定义的常量，若是在编译时就已经肯定了值，在引用时不会触发初始化，由于在编译的时候就已经肯定下来，就是“宏变量”。若是在编译时没法肯定，在初次使用才会致使初始化。
public class StaticInnerSingleton {
/**
* 使用静态内部类实现单例：
* 1：线程安全
* 2：懒加载
* 3：非反序列化安全，即反序列化获得的对象与序列化时的单例对象不是同一个，违反单例原则
*/
private static class LazyHolder {
private static final StaticInnerSingleton INNER_SINGLETON = new StaticInnerSingleton();
}
private StaticInnerSingleton() {
}
public static StaticInnerSingleton getInstance() {
return LazyHolder.INNER_SINGLETON;
}
}
看这个例子，单例模式静态内部类实现方式。咱们能够看到单例实例使用final定义，但在编译时没法肯定下来，因此在第一次使用StaticInnerSingleton.getInstance()方法时，才会触发静态内部类的加载，也就是延迟加载。这里想指出，若是final定义的变量在编译时没法肯定，则在使用时仍是会进行类的初始化。
3.四、ClassLoader只会对类进行加载，不会进行初始化
public class Tester {
static {
System.out.println("Tester类的静态初始化块");
}
}
class ClassLoaderTest {
public static void main(String[] args) throws ClassNotFoundException {
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
//下面语句仅仅是加载Tester类
classLoader.loadClass("loader.Tester");
System.out.println("系统加载Tester类");
//下面语句才会初始化Tester类
Class.forName("loader.Tester");
}
}
//输出结果
//系统加载Tester类
//Tester类的静态初始化块
从输出证实：ClassLoader只会对类进行加载，不会进行初始化；使用Class.forName()会强制致使类的初始化。
3、类加载器
类加载器负责将.class文件（不论是jar,仍是本地磁盘，仍是网络获取等等）加载到内存中，并为之生成对应的java.lang.Class对象。一个类被加载到JVM中，就不会第二次加载了。
那怎么判断是同一个类呢？
每一个类在JVM中使用全限定类名（包名+类名）与类加载器联合为惟一的ID，因此若是同一个类使用不一样的类加载器，能够被加载到虚拟机，但彼此不兼容。
一、JVM类加载器分类
1.一、Bootstrap ClassLoader
Bootstrap ClassLoader为根类加载器，负责加载java的核心类库。根加载器不是ClassLoader的子类，是有C++实现的。
public class BootstrapTest {
public static void main(String[] args) {
//获取根类加载器所加载的所有URL数组
URL[] urLs = Launcher.getBootstrapClassPath().getURLs();
Arrays.stream(urLs).forEach(System.out::println);
}
}
//输出结果
//file:/C:/SorftwareInstall/java/jdk/jre/lib/resources.jar
//file:/C:/SorftwareInstall/java/jdk/jre/lib/rt.jar
//file:/C:/SorftwareInstall/java/jdk/jre/lib/sunrsasign.jar
//file:/C:/SorftwareInstall/java/jdk/jre/lib/jsse.jar
//file:/C:/SorftwareInstall/java/jdk/jre/lib/jce.jar
//file:/C:/SorftwareInstall/java/jdk/jre/lib/charsets.jar
//file:/C:/SorftwareInstall/java/jdk/jre/lib/jfr.jar
//file:/C:/SorftwareInstall/java/jdk/jre/classes
根类加载器负责加载%JAVA_HOME%/jre/lib下的jar包（以及由虚拟机参数 -Xbootclasspath 指定的类）。
咱们将rt.jar解压，能够看到咱们常用的类库就在这个jar包中。
1.2 、Extension ClassLoader
Extension ClassLoader为扩展类加载器，负责加载%JAVA_HOME%/jre/ext或者java.ext.dirs系统熟悉指定的目录的jar包。你们能够将本身写的工具包放到这个目录下，能够方便本身使用。
1.三、 System ClassLoader
System ClassLoader为系统（应用）类加载器，负责加载加载来自java命令的-classpath选项、java.class.path系统属性，或者CLASSPATH环境变量所指定的JAR包和类路径。程序能够经过ClassLoader.getSystemClassLoader()来获取系统类加载器。若是没有特别指定，则用户自定义的类加载器默认都以系统类加载器做为父加载器。
4、类加载机制
1.一、JVM主要的类加载机制。
- 全盘负责：当一个类加载器负责加载某个Class时，该Class所依赖和引用的其余Class也由该类加载器负责载入，除非显示使用另外一个类加载器来载入。
- 父类委托（双亲委派）：先让父加载器试图加载该Class，只有在父加载器没法加载时该类加载器才会尝试从本身的类路径中加载该类。
- 缓存机制：缓存机制会将已经加载的class缓存起来，当程序中须要使用某个Class时，类加载器先从缓存区中搜寻该Class，只有当缓存中不存在该Class时，系统才会读取该类的二进制数据，并将其转换为Class对象，存入缓存中。这就是为何更改了class后，须要重启JVM才生效的缘由。
注意：类加载器之间的父子关系并非类继承上的父子关系，而是实例之间的父子关系。
public class ClassloaderPropTest {
public static void main(String[] args) throws IOException {
//获取系统类加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println("系统类加载器：" + systemClassLoader);
/*
获取系统类加载器的加载路径——一般由CLASSPATH环境变量指定，若是操做系统没有指定
CLASSPATH环境变量，则默认以当前路径做为系统类加载器的加载路径
*/
Enumeration<URL> eml = systemClassLoader.getResources("");
while (eml.hasMoreElements()) {
System.out.println(eml.nextElement());
}
//获取系统类加载器的父类加载器，获得扩展类加载器
ClassLoader extensionLoader = systemClassLoader.getParent();
System.out.println("系统类的父加载器是扩展类加载器：" + extensionLoader);
System.out.println("扩展类加载器的加载路径：" + System.getProperty("java.ext.dirs"));
System.out.println("扩展类加载器的parant：" + extensionLoader.getParent());
}
}
//输出结果
//系统类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
//file:/C:/ProjectTest/FengKuang/out/production/FengKuang/
//系统类的父加载器是扩展类加载器：sun.misc.Launcher$ExtClassLoader@1540e19d
//扩展类加载器的加载路径：C:\SorftwareInstall\java\jdk\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext
//扩展类加载器的parant：null
从输出中验证了：系统类加载器的父加载器是扩展类加载器。但输出中扩展类加载器的父加载器是null，这是由于父加载器不是java实现的，是C++实现的，因此获取不到。但扩展类加载器的父加载器是根加载器。
1.二、类加载流程图
图中红色部分，能够是咱们自定义实现的类加载器来进行加载。
5、建立并使用自定义类加载器
一、自定义类加载分析
除了根类加载器，全部类加载器都是ClassLoader的子类。因此咱们能够经过继承ClassLoader来实现本身的类加载器。
ClassLoader类有两个关键的方法：
- protected Class loadClass(String name, boolean resolve)：name为类名，resove若是为true，在加载时解析该类。
- protected Class findClass(String name) ：根据指定类名来查找类。
因此，若是要实现自定义类，能够重写这两个方法来实现。但推荐重写findClass方法，而不是重写loadClass方法，由于loadClass方法内部回调用findClass方法。
咱们来看一下loadClass的源码
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
//第一步，先从缓存里查看是否已经加载
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
//第二步，判断父加载器是否为null
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
//第三步，若是前面都没有找到，就会调用findClass方法
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
loadClass加载方法流程：
- 判断此类是否已经加载；
- 若是父加载器不为null，则使用父加载器进行加载；反之，使用跟加载器进行加载；
- 若是前面都没加载成功，则使用findClass方法进行加载。
因此，为了避免影响类的加载过程，咱们重写findClass方法便可简单方便的实现自定义类加载。
二、实现自定义类加载器
基于以上分析，咱们简单重写findClass方法进行自定义类加载。
public class Hello {
public void test(String str){
System.out.println(str);
}
}
public class MyClassloader extends ClassLoader {
/**
* 读取文件内容
*
* @param fileName 文件名
* @return
*/
private byte[] getBytes(String fileName) throws IOException {
File file = new File(fileName);
long len = file.length();
byte[] raw = new byte[(int) len];
try (FileInputStream fin = new FileInputStream(file)) {
//一次性读取Class文件的所有二进制数据
int read = fin.read(raw);
if (read != len) {
throw new IOException("没法读取所有文件");
}
return raw;
}
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
Class clazz = null;
//将包路径的(.)替换为斜线(/)
String fileStub = name.replace(".", "/");
String classFileName = fileStub + ".class";
File classFile = new File(classFileName);
//若是Class文件存在，系统负责将该文件转换为Class对象
if (classFile.exists()) {
try {
//将Class文件的二进制数据读入数组
byte[] raw = getBytes(classFileName);
//调用ClassLoader的defineClass方法将二进制数据转换为Class对象
clazz = defineClass(name, raw, 0, raw.length);
} catch (IOException e) {
e.printStackTrace();
}
}
//若是clazz为null,代表加载失败，抛出异常
if (null == clazz) {
throw new ClassNotFoundException(name);
}
return clazz;
}
public static void main(String[] args) throws Exception {
String classPath = "loader.Hello";
MyClassloader myClassloader = new MyClassloader();
Class<?> aClass = myClassloader.loadClass(classPath);
Method main = aClass.getMethod("test", String.class);
System.out.println(main);
main.invoke(aClass.newInstance(), "Hello World");
}
}
//输出结果
//Hello World
ClassLoader还有一个重要的方法defineClass(String name, byte[] b, int off, int len)。此方法的做用是将class的二进制数组转换为Calss对象。
此例子很简单，我写了一个Hello测试类，而且编译事后放在了当前路径下（你们能够在findClass中加入判断，若是没有此文件，能够尝试查找.java文件，并进行编译获得.class文件；或者判断.java文件的最后更新时间大于.class文件最后更新时间，再进行从新编译等逻辑）。
6、总结
本篇从类加载的三大阶段：加载、连接、初始化开始细说每一个阶段的过程；详细讲解了JVM经常使用的类加载器的区别与联系，以及类加载机制流程，最后经过自定义的类加载器例子结束本篇。小弟能力有限，你们看出有问题请指出，让博主学习改正。欢迎讨论啊。
注意：本篇博客总结主要来源。若有转载，请注明出处
- 《疯狂java讲义（第3版）》
- 《深刻理解java虚拟机++JVM高级特性与最佳实践》
- 1. 类加载流程，类加载机制及自定义类加载器详解（面试不再怕了）
- 2. 面试官：请详细解说一下 类加载流程，类加载机制及自定义类加载器
- 3. 类加载机制及类加载器加载Class流程
- 4. JVM类加载机制——自定义类加载器
- 5. 类加载机制（类加载过程和类加载器）
- 6. Java类加载机制及自定义加载器
- 7. 类加载机制：类加载过程
- 8. 自定义类加载器
- 9. 自定义 类加载器
- 10. 类加载过程及类加载器
- 更多相关文章...
- • ionic 加载动作 - ionic 教程
- • ionic 加载动画 - ionic 教程
- • Kotlin学习（二）基本类型
- • 使用阿里云OSS+CDN部署前端页面与加速静态资源
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 外部其他进程嵌入到qt FindWindow获得窗口句柄 报错无法链接的外部符号 [email protected] 无法被([email protected]@[email protected]@@引用
- 2. UVa 11524 - InCircle
- 3. The Monocycle（bfs）
- 4. VEC-C滑窗
- 5. 堆排序的应用-TOPK问题
- 6. 实例演示ElasticSearch索引查询term,match,match_phase,query_string之间的区别
- 7. 数学基础知识 集合
- 8. amazeUI 复择框问题解决
- 9. 背包问题理解
- 10. 算数平均-几何平均不等式的证明,从麦克劳林到柯西