类的加载顺序
一个class进来进行loading加载到内存中,然后进行linking,linking中又分为verification(检查),preparartion(准备),resolution(处理)。接着进行initalizing初始化给静态变量赋初始值,判断为无用类进行GC回收。
linking模块进行描述:
verification->用来检查加载进来的class是否符合解析的标准
preparartion->给class的静态变量赋默认值,一般基本类型为0,引用类型为null。
resolution->将class类中常量池中的地址符号转换成为直接的内存地址,及可访问的内存地址
类加载器与双亲委派机制
1.Bootstrap类加载器为顶级的classloader加载路径为<JAVA_HOME>\lib目录中jar文件
2.Extension加载器负责加载<JAVA_HOME>\lib\ext目录中的jar文件
3.App加载器负责加载用户类路径(ClassPath)上所指定的类库,如果应用程序中没有自定义自己的类加载器,一般情况下这个就是程序中默认的类加载器。
4.Custom为自定义加载器,由用户自己实现。
JVM是按需动态加载,采用双亲委派机制,自底部往上检查该类是否加载(图中1>2>3的顺序),如果没有classloader加载过该类则会自上而下(4>5>6)再去查找加载class,直到找到该class并加载到内存中。
采用双亲委派机制的好处是为了安全,避免外部加载进来的类和内部classloader链中产生冲突,做恶意破坏,如果有同名的类被加载进来JVM首先会判断是否有这样一个类已经加载过,如果已经加载则不会再加载一次该类。
下面我们来看下classloader的源码
name参数为class的名称,实际调用的是loadClass()
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
再来看看loadClass().
先findLoadedClass加载类,如果返回为null则调用 parent.loadClass();这里的parent即为上图中classloader的父级classloader,依次调用如果都找不到在调用findClass()
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {
**//自下而上loadclass**
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) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
**//自上而下findclass**
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;
}
}
如果想要自定义classloader 直接继承ClassLoader并重写findclass方法,在findclass中调用defaulclass()传入需要加载的class信息。下面上代码
public class MyClassloader extends ClassLoader{
@SneakyThrows
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
FileInputStream fileInputStream = null;
ByteArrayOutputStream byteArrayOutputStream = null;
try {
fileInputStream=new FileInputStream(new File(name));
byteArrayOutputStream=new ByteArrayOutputStream();
int i;
while ((i=fileInputStream.read())!=-1){
byteArrayOutputStream.write(i);
}
byte[] classByte=byteArrayOutputStream.toByteArray();
return defineClass(name,classByte,0,classByte.length);
}catch (Exception e){
e.printStackTrace();
}finally {
fileInputStream.close();
byteArrayOutputStream.close();
}
return super.findClass(name);
}
public static void main(String[] args) {
ClassLoader classLoader=new MyClassloader();
try {
classLoader.loadClass("C:/test.class");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
如何打破双亲委派机制?
我们从上述源码可以推断,只要重写ClassLoader的loadClass()方法,在loadClass方法中不在调用父类的loadClass(),而是直接去load自己的class,这样就可以打破双亲委派机制。
举一个列子:tomcate的热部署就是打破了双亲委派机制,修改一个class文件可以立即同步到上下文中,其实本质就是重新加载了一次该class,如果有感兴趣的可以去了解一下tomcat的实现原理里面大致应该也是重写了loadClass()方法。
懒加载
类的加载不是在初始化时loading所有的类,而是在用到的时候才会去加载class。即会发生懒加载,懒加载有五种情况:
1.new对象,获取和访问静态变量,记住访问final变量除外
2.java.lang.reflect对类进行反射调用时
3.初始化子类的时候,父类首先初始化
4.虚拟机启动时,被执行的主类必须初始化
5.动态语言支持java.lang.invoke.MethodHandle解析的结果为REF_getstatic REF_putstatic REF_invokestatic的方法句柄时,该类必须初始化