详解JVM类加载机制及类缓存问题的处理方法
前言
大家应该都知道，当一个java项目启动的时候，jvm会找到main方法，根据对象之间的调用来对class文件和所引用的jar包中的class文件进行加载（其步骤分为加载、验证、准备、解析、初始化、使用和卸载），方法区中开辟内存来存储类的运行时数据结构（包括静态变量、静态方法、常量池、类结构等），同时在堆中生成相应的class对象指向方法区中对应的类运行时数据结构。
用最简单的一句话来概括，类加载的过程就是jvm根据所需的class文件的路径，通过io流的方式来读取class字节码文件，并通过一系列解析初始化等步骤来注入到内存。 java中的类加载器有：bootstrapclassloader（最上层）、extclassloader、appclassloader、以及用户自定义的classloader（最下层）。jvm对于不同种类的jar包（或class文件），会有不同种类的类加载器进行加载。
对应关系如下：
bootstrapclassloader 用于加载jvm运行所需要的类：
java_home/jre/lib/resources.jar: java_home/jre/lib/rt.jar: java_home/jre/lib/sunrsasign.jar: java_home/jre/lib/jsse.jar: java_home/jre/lib/jce.jar: java_home/jre/lib/charsets.jar: java_home/jre/lib/jfr.jar: java_home/jre/classes
extclassloader 用于加载扩展类：
../java/extensions: ../java_home/jre/lib/ext: ../library/java/extensions:/network/library/java/extensions: ../system/library/java/extensions: ../lib/java
appclassloader 用于加载我们项目中classpath下所创建的类和jar包中引用的类。
整个类加载，是通过一种叫做双亲委派的机制来进行加载。
举例来说，一个类被最下层的加载器（用户自定义classloader）进行加载，此加载器首先会调用上一层的加载器（appclassloader）进行加载，而appclassloader会继续转交给上层（extclassloader）的加载器进行加载，直到bootstrapclassloader。 如果bootstrapclassloader所加载的类路径找不到此类，那么才会交给下一层的加载器（extclassloader）进行加载，如果找不到此类，继续交给下一层（appclassloader）进行加载。以此类推，如果用户自定义的classloader也找不到此类，那么程序就会抛出一个classnotfounderror。
整个加载过程图示如下：
（图片引用自：https://www.cnblogs.com/xing901022/p/4574961.html）
类加载源的源码跟踪如下（在此对源码进行了适当的简化），读者可以点入源码进行查看：
package java.lang.classloader;
import ....
protected class<?> loadclass(string name, boolean resolve)
throws classnotfoundexception
{
synchronized (getclassloadinglock(name)) {
// first，在虚拟机内存中查找是否已经加载过此类...类缓存的主要问题所在！！！
class<?> c = findloadedclass(name);
if (c == null) {
long t0 = system.nanotime();
try {
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方法进行加载
c = findclass(name);
}
}
if (resolve) {
resolveclass(c);
}
return c;
}
}
在源码中可以完全领略到双亲委派机制的过程，其中最重要的三句代码已经进行了标注：
- findloadedclass（在虚拟机内存中查找是否已经加载过此类...类缓存的主要问题所在！！！）
- parent.loadclass（先让上一层加载器进行加载）
- findclass（调用此类加载器所实现的findclass方法进行加载）
如果用户需要自定义加载器，加载自己指定路径的class文件，需要继承classloader，并实现findclass(string name)方法。举例如下：
package com.linuxidc.utils;
import java.io.bytearrayoutputstream;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.inputstream;
public class serviceclassloader extends classloader{
private string classpath;
public serviceclassloader(string classpath) {
this.classpath = classpath;
}
/**
* 重写父类的findclass 方法。 父类的loadclass会调用此方法
*/
@override
protected class<?> findclass(string name) throws classnotfoundexception {
class<?> c = null;
byte[] classdata = getclassdata(name);
if (classdata!=null) {
c = defineclass(name, classdata, 0, classdata.length);
}else {
throw new classnotfoundexception();
}
return c;
}
// 将class文件通过io流读取，转化为字节数组
private byte[] getclassdata(string name) {
string path = classpath + "/"+ name.replace('.', '/') + ".class";
inputstream istream = null;
bytearrayoutputstream bytearrayoutputstream = new bytearrayoutputstream();
try {
istream = new fileinputstream(path);
byte[] buffer = new byte[1024];
int temp = 0;
while ((temp = istream.read(buffer))!=-1) {
bytearrayoutputstream.write(buffer, 0, temp);
}
if (bytearrayoutputstream!=null) {
return bytearrayoutputstream.tobytearray();
}
} catch (exception e) {
e.printstacktrace();
}finally {
try {
if (istream!=null) {
istream.close();
}
} catch (ioexception e) {
e.printstacktrace();
}
try {
if (bytearrayoutputstream!=null) {
bytearrayoutputstream.close();
}
} catch (ioexception e) {
e.printstacktrace();
}
}
return null;
}
}
对类加载器的使用代码如下：
serviceclassloader serviceclassloader = new serviceclassloader("c:\myclass");
czlass<?> c = serviceclassloader.loadclass("com.linuxidc.service.myclass");
如果 用同一个 serviceclassloader 对象去加载同一个class文件多次，每次加载后的class对象为同一个！ 然而如果new不同的自定义classloader去加载同一个class文件，则每次会返回不同的class对象。
注意： 不能将所要加载的class文件放到classpath目录及其任何子目录下，否则会被appclassloader优先加载 （这是由于类加载采用双亲委派机制，同时appclassloader可以加载所有在classpath下的class文件）， 每次都是同一个appclassloader进行加载，因此会出现类缓存问题。
这样就解决了通常在jvm类加载时，直接使用反射出现的类缓存的问题。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。