深入理解类加载

最新推荐文章于 2021-10-29 22:02:08 发布

置顶安安静静的学习579

最新推荐文章于 2021-10-29 22:02:08 发布

阅读量190

点赞数

分类专栏：编程

本文链接：https://blog.csdn.net/weixin_45608849/article/details/106298122

版权

编程专栏收录该内容

37 篇文章 0 订阅

订阅专栏

一、类加载的时机

如果类没有进行初始化，就需要先对类进行初始化

创建类的实例(new 操作)。访问某个类或者接口的静态变量，或者对静态变量赋值，调用类的静态方法 (类.XXX调用)
反射
初始化某个子类，则其父类也会被初始化
Java虚拟机启动时被标明为启动类的类，直接使用java.exe命令来运行某个主类（运行main方法时，会先加载包含main的类）

二、类的生命周期

有7个阶段：加载、验证、准备、解析、初始化、使用和卸载
在这里插入图片描述

类加载的全过程：加载、验证、准备、解析和初始化这5个阶段

加载：通过一个类的完全限定查找此类字节码文件，并利用字节码文件创建一个Class对象
验证：目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，不会危害虚拟机自身安全。主要包括：文件格式验证、元数据验证、字节码验证、符号引用验证
准备：为类变量(静态变量，即static修饰的字段变量)分配内存并且设置该类变量的初始值为0（如：public static a = 10，这步a的初始化为0，在后面初始化时才给变量进行赋值），这里不包含用final修饰的static，因为final在编译的时候就会分配空间了，也不会为实例变量分配初始化，类变量会分配在方法区，而实例变量会随着对象分配到Java堆中
解析：主要将常量池中的符号引用替换为直接引用的过程。

符号引用：一组符号来描述目标，可以是任何字面量。引用的目标不一定已经加载到内存中
直接引用：直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。引用的目标必定已在内存中存在

初始化：类加载最后阶段，若该类具有父类，则对其进行初始化，执行静态初始化器和静态初始化成员变量。

1.静态语句块中只能访问到定义在静态语句块之前的变量，定义在之后的变量，只能赋值，不能访问。
2.虚拟机会保证在子类的init()方法执行之前，父类的clinit()方法已经执行完毕。
3.clinit()方法对于类或接口来说并不是必需的，如果一个类中没有静态语句块，也没有对变量的赋值操作，那么编译器可以不为这个类生成clinit()方法。
4.接口中定义的变量使用时，接口才会初始化，接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样都会产生clinit()方法，但执行接口的clinit()方法不需要先执行父接口的clinit()方法，只有当父接口中定义的变量使用时，父接口才会初始化，接口的实现类在初始化时也不会执行clinit()方法。
5.虚拟机会保证一个类的clinit()方法在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的clinit()方法，其他线程都需要阻塞等待，直到活动线程执行完毕。

三、类加载器

类加载器的任务是根据一个类的全限定名来读取此类的二进制字节流到JVM中，然后转换为一个与目标类对应的java.lang.Class对象实例
类加载器可以分为： 启动类加载器、扩展类加载器、应用程序类加载器、自定义类加载器，关系如下：
在这里插入图片描述
启动类加载器：
启动类加载器主要加载的是JVM自身需要的类，负责将存放在<JAVA_HOME>\lib目录中的，或者被-Xbootclasspath参数所指定的路径中的jar包，并且是虚拟机识别的（仅按照文件名识别，如rt.jar，名字不符合的类库即使放在lib目录下也不会被加载）类库加载到虚拟机内存中（出于安全考虑，启动类加载器只加载包名为java、javax、sun等开头的类）。

启动类加载器无法被Java程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给引导类加载器，那直接使用null指定父类加载器即可。

public class MyClassLoader extends ClassLoader{
	
	protected MyClassLoader (ClassLoader parent){
		super(parent);
	}

	// 使用ClassLoader父类的构造方法：根据ClassLoader中loadClass可以知道，设置父类加载器为null会使用启动类加载器来加载
	protected MyClassLoader (){
		this(null);
	} 
}

扩展类加载器：
扩展类加载器是由sun.misc.Launcher $ExtClassLoader实现，他负责加载<JAVA_HOME>\lib\exe目录中的，或者被java.ext.dirs系统变量所指定的路径中所有的类库，开发者可以直接使用扩展类加载器。
应用程序类加载器：
应用程序类加载器由sun.misc.Launcher $App-ClassLoader实现，由于这个类加载器是ClassLoader中的getSystemClassLoader()方法的返回值，所以一般称它为系统类加载器，负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用，如果没有定义过自己的类加载器，一般情况下程序的默认类加载器就是应用程序类加载器。
以上的类加载器都是属于双亲委派机制

四.双亲委派机制

在这里插入图片描述
双亲委派模型的工作过程是：如果一个类加载器收到一个类加载的请求，它就先把这个请求委托给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传递给顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求，子加载器才会尝试自己加载。
使用双亲委派模型的好处是：Java类随着它的类加载器一起具备了一种带有优先级的层次关系，例如类java.lang.Object，它存放在rt.jar之中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的启动类加载器进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。

1.如果没有使用双亲委派模型，由各个类加载器自行去加载，如果用户自己编写了java.lang.Object的类,并放在程序的ClassPath中，那么系统将会出现多个不同的Object类；
2. 如果没有使用双亲委派模型，用户编写了java.lang.Object的类，用自定义的类加载器去加载，那么结果会导致侵入项目，发生一些事故

1.可以通过动态的路径进行类的加载操作
2.比较两个类相等的前提：必须是由同一个加载器加载的前提下才有意义

以下为ClassLoader中的代码：

// The parent class loader for delegation
// Note: VM hardcoded the offset of this field, thus all new fields
// must be added *after* it.
// 父类加载器
private final ClassLoader parent;

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 {
                // 父类加载器加载，如果父类加载器为空，使用最顶级的Bootstrap类加载器来加载
                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) {
                // If still not found, then invoke findClass in order
                // to find the class.
                // 如果以上步骤还没找到类，就按照自己定义的类加载器中重写的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;
    }
}

双亲委派的具体逻辑就实现在这个方法之中，JDK1.2之后已不提倡用户再去覆盖loadClass（）方法，而应当把自己的类加载逻辑写到findClass（）方法中，在loadClass（）方法的逻辑里如果父类加载失败，则会调用自己的findClass（）方法来完成加载，这样就可以保证新写出来的类加载器是符合双亲委派规则的。
重写loadClass()：不遵循双亲委派机制，按照自己的方式加载
重写findClass()：遵循双亲委派机制，只有父类找不到时，才按照自己的方式加载

观察类加载器的加载顺序：
先定义一个java.lang.String：

package java.lang;
public class String {
    public String(String string) {
        System.out.println("自定义的java.lang.String类");
    }
}

再定义一个Person类：

public class Person{}

使用自定义的类加载器来加载以上两个类：

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.URL;
import java.net.URLDecoder;

public class Main {
    public static void main(String[] args) throws Exception{
        // 父加载器为空，使用Bootstrap ClassLoader加载
        System.out.println(new MyClassLoader(null).getParent());//null

        // 无参构造方法，会使用AppClassLoader作为父类加载器
        System.out.println(new MyClassLoader());
        System.out.println(new MyClassLoader().getParent());//App
        System.out.println(new MyClassLoader().getParent().getParent());//Ext
        System.out.println(new MyClassLoader().getParent().getParent().getParent());//null
        // 父加载器默认为AppClassLoader，使用loadClass方法加载类，从上往下加载
        Class<?> cls = new MyClassLoader().loadClass("Person");

        // 使用loadClass遵循双亲委派机制从上往下加载，会加载到jdk的String
        Class<?> stringClazz = new MyClassLoader().loadClass("java.lang.String");
        String abc = (String) stringClazz.getConstructor(String.class)
                .newInstance("ABC");
        System.out.println(abc);

        //出现异常：不能自定义java.开头的包
        Class<?> stringClazz2 = new MyClassLoader().findClass("java.lang.String");
    }
}
class MyClassLoader extends ClassLoader{
    protected MyClassLoader(ClassLoader parent) {
        super(parent);
    }
    protected MyClassLoader() {
        super();
    }
    /**
     * 通过指定的文件路路径进行类的文件加载，实际上就是进行二进制文件读取
     * @return 类文件数据
     * @throws Exception
     */
    private byte[] loadClassData(String className) throws Exception {
        URL target = getClass().getClassLoader().getResource(".");
        String path = URLDecoder.decode(target.getPath(), "UTF-8");
        InputStream input = new FileInputStream(
                path + File.separator + className + ".class");
        // 取得所有字节内容，放到内存中
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        // 读取缓冲区
        byte[] data = new byte[20];
        int temp = 0;
        while ((temp = input.read(data))!=-1){
            bos.write(data,0,temp);
        }
        byte[] result = bos.toByteArray();
        input.close();
        bos.close();
        return result;
    }

    /**
     * 重写findClass表示遵循双亲委派模型，因为类的加载还是通过loadClass方法进入的
     * @param name
     * @return
     * @throws ClassNotFoundException
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] classData = this.loadClassData(name.replaceAll("\\.", "/"));
            return super.defineClass(name, classData,0, classData.length);
        } catch (Exception e) {
        	e.printStackTrace();
            throw new ClassNotFoundException();
        }
    }
}

安安静静的学习579

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
深入理解类加载

一、类加载的时机如果类没有进行初始化，就需要先对类进行初始化创建类的实例(new 操作)。访问某个类或者接口的静态变量，或者对静态变量赋值，调用类的静态方法 (类.XXX调用)反射初始化某个子类，则其父类也会被初始化Java虚拟机启动时被标明为启动类的类，直接使用java.exe命令来运行某个主类（运行main方法时，会先加载包含main的类）二、类的生命周期有7个阶段：加载、验证、准备、解析、初始化、使用和卸载类加载的全过程：加载、验证、准备、解析和初始化这5个阶段加载：通过一个类的
复制链接

扫一扫