【JVM】类加载子系统

已于 2022-11-04 14:10:39 修改
阅读量236 收藏
点赞数
分类专栏： JVM 文章标签： jvm java 算法
于 2022-10-22 17:01:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48848473/article/details/127396666
版权

一，内存结构

在这里插入图片描述

二，类加载器及类加载过程

1，类加载器子系统作用

在这里插入图片描述

  1. 类加载器子系统负责从文件系统或者网络中加载Class文件，Class文件在文件开头有特定的文件标识；
  2. ClassLoader只负责class文件的加载，至于它是否可以运行，则由ExceptionEngine决定；
  3. 加载的类信息存放于一块称为方法区的内存空间（并且生成Class的实例），除了类的信息外，方法区中还会存放运行时常量池信息，可能还包括字符串字面量和数字常量（这部分常量信息是Class文件中常量池部分的内存映射）。
    运行时常量池信息如下：
    在这里插入图片描述
    使用软件Binary Viewer打开我们的字节码文件（Class文件），这里CA FE BA BE就是java特定的文件标识
    在这里插入图片描述

2，类加载器ClassLoader角色

在这里插入图片描述
4. class file （如上图中的Car.class）存放于本地硬盘上，可以理解为设计师画在纸上的模板，而最终这个模板在执行的时候是要加载到JVM当中来根据这个文件实例化出n个一模一样的实例（如上图中的car1, car2, car3）；
5. class file 加载到JVM中，被称为DNA元数据模板（如上图中的Car Class），放在方法区；
6. 在.class文件 -> JVM -> 最终成为元数据模板，此过程就要一个运输工具（类加载器 Class Loader），扮演一个快递员的角色。

3，类加载过程

3.1，总体流程

在这里插入图片描述
当我们在执行一个类（比如上图中的HelloLoader）的main方法
首先判断类是否装载，如果没有通过类加载器ClassLoader进行装载，如果出现异常（比如字节码文件被篡改）会抛出异常，装载成功后，即可通过链接，然后初始化类，调用main方法，最后结束程序。

3.2，具体步骤

在这里插入图片描述
加载

  1. 通过一个类的全限定名获取定义此类的二进制字节流
  2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
  3. 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

链接

  1. 验证（Verify）
  • 目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，保证被加载类的正确性，不会危害虚拟机自身的安全；
  • 主要包括四种验证：文件格式验证，元数据验证，字节码验证，符号引用验证。
  1. 准备 （Prepare）
  • 为类变量分配内存并且设置该类变量的默认初始值，即零值；
  • 这里不包含用final修饰的static，因为final在编译的时候就会分配了，准备阶段会显式初始化；
  • 这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中。
    在这里插入图片描述
  1. 解析（Resolve）
  • 将常量池内的符号引用转换为直接引用的过程；
  • 事实上，解析操作往往会伴随着JVM在执行初始化之后再执行；
  • 符号引用就是一组符号来描述所引用的目标，符号引用的字面量形式明确定义在《java虚拟机规范》的Class文件格式中，直接引用就是直接指向目标的指针，相对偏移量或一个间接定位到目标的句柄；
  • 解析动作主要对类或接口，字段，类方法，接口方法，方法类型等，对应常量池中的CONSTANT_Class_info，CONSTANT_Fieldref_info，CONSTANT_Methodref_info等。

初始化

  • 初始化阶段就是执行类构造器方法()的过程；
  • 此方法不需要定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来；
  • 构造器方法中指令按语句在源文件中出现的顺序执行；
  • ()不同于类的构造器；（关联：构造器是虚拟机视角下()）
  • 若该类具有父类，JVM会保证子类的()执行前，父类的()已经执行完毕；
  • 虚拟机必须保证一个类的()方法在多线程下被同步加锁。（类加载到内存中后使用的直接内存，被缓存起来了，再使用这个类，实际上是使用了已存在的这个类的类本身，因此clinit只会被加载一次）
    如下代码：
package com.drhj;

/**
 * Author: DRHJ
 * Date: 2022/10/19 20:54
 */
public class ClassInitTest {
    private static int num = 1;

    public static void main(String[] args) {
        System.out.println(ClassInitTest.num);
    }

}

运行编译为字节码文件后，我们使用jclasslib软件打开，
在这里插入图片描述
将变量1引进来了
当修改代码：

package com.drhj;

/**
 * Author: DRHJ
 * Date: 2022/10/19 20:54
 */
public class ClassInitTest {
    private static int num = 1;

    static {
        num = 2;
    }

    public static void main(String[] args) {
        System.out.println(ClassInitTest.num);
    }

}

在这里插入图片描述
先赋值1，再赋值2，可见构造器将显式初始化和静态初始化放在了一起

package com.drhj;

/**
 * Author: DRHJ
 * Date: 2022/10/19 20:54
 */
public class ClassInitTest {
    private static int num = 1;

    static {
        num = 2;
        number = 20;
    }
    
    private static int number = 10; //linking中的Prepare: number = 0 --> initial: 20 --> 10

    public static void main(String[] args) {
        System.out.println(ClassInitTest.num);
        System.out.println(ClassInitTest.number);
    }

}

在这里插入图片描述
在这里插入图片描述
可见是按顺序执行

注意：如果变量定义在后面，则不能在前面进行引用

package com.drhj;

/**
 * Author: DRHJ
 * Date: 2022/10/19 20:54
 */
public class ClassInitTest {
    private static int num = 1;

    static {
        num = 2;
        number = 20;
        System.out.println(num);
        System.out.println(number); //报错: 非法的前向引用
    }

    private static int number = 10; //linking中的Prepare: number = 0 --> initial: 20 --> 10

    public static void main(String[] args) {
        System.out.println(ClassInitTest.num);
        System.out.println(ClassInitTest.number);
    }

}

只是将类变量的赋值动作和静态代码块结合而来，

package com.drhj;

/**
 * Author: DRHJ
 * Date: 2022/10/19 21:17
 */
public class ClinitTest {
    private int a = 1;

    public static void main(String[] args) {
        int b = 2;
    }
}

在这里插入图片描述
没有出现clinit初始化

init是类的构造器，每个类都会有构造器，如果没写，则会有默认的无参构造

package com.drhj;

/**
 * Author: DRHJ
 * Date: 2022/10/19 21:17
 */
public class ClinitTest {
    //任何一个类声明以后，内部至少存在一个类的构造器
    private int a = 1;
    private static int c = 3;

    public ClinitTest() {
        a = 10;
        int d = 20;
    }

    public static void main(String[] args) {
        int b = 2;
    }
}

在这里插入图片描述

package com.drhj;

/**
 * Author: DRHJ
 * Date: 2022/10/19 22:10
 */
public class DeadThreadTest {
    public static void main(String[] args) {
        Runnable r = () -> {
            System.out.println(Thread.currentThread().getName() + "开始");
            DeadThread dead = new DeadThread();
            System.out.println(Thread.currentThread().getName() + "结束");
        };

        Thread t1 = new Thread(r, "线程1");
        Thread t2 = new Thread(r, "线程2");

        t1.start();
        t2.start();
    }
}

class DeadThread {
    static {
        if (true) {
            System.out.println(Thread.currentThread().getName() + "初始化当前类");
            while (true) {

            }
        }
    }
}

在这里插入图片描述
一个类只会被加载一次，多线程下会被加锁。

三，类加载器的分类

  • JVM支持两种类型的类加载器，分别为引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-Defind ClassLoader）ps: Bootstrap ClassLoader是使用C，C++编写的;
  • 从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类加载器，但是Java虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器；
  • 无论类加载器的类型如何划分，在程序中我们最常见的类加载器始终只有3个，如下所示：
    在这里插入图片描述
    上述关系类似路径总file: /a/b/c.txt 中a，b，c的关系
package com.drhj;

/**
 * Author: DRHJ
 * Date: 2022/10/19 22:32
 */
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@1b6d3586

        //获取其上层: 获取不到引导类加载器
        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
    }
}

1，虚拟机自带的加载器

1.1，启动类加载器（引导类加载器，Bootstrap ClassLoader）

  • 这个类加载使用C/C++语言实现的，嵌套在JVM内部；
  • 它用来加载Java的核心库（JAVA_HOME/jre/lib.rt.jar，resources.jar或sun.boot.class.path路径下的内容），用于提供JVM自身需要的类；
  • 并不继承自java.lang.ClassLoader，没有父加载器；
  • 加载拓展类和应用程序类加载器，并指定为他们的父类加载器；
  • 出于安全考虑，Bootstrap启动类加载器只加载包名为java，javax，sun等开头的类。
package com.drhj;

import java.net.URL;
import java.security.Provider;

/**
 * Author: DRHJ
 * Date: 2022/10/20 22:14
 */
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);
    }
}

在这里插入图片描述

1.2，拓展类加载器（Extension ClassLoader）

  • Java语言编写，由sun.misc.Launcher$ExtClassLoader实现；
  • 派生于ClassLoader类；
  • 父类加载为启动类加载器；
  • 从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录（拓展目录）下加载类库，如果用户创建的JAR放在此目录下，也会自动由拓展类加载器加载。
package com.drhj;

import sun.security.ec.CurveDB;

import java.net.URL;
import java.security.Provider;

/**
 * Author: DRHJ
 * Date: 2022/10/20 22:14
 */
public class ClassLoaderTest1 {
    public static void main(String[] args) {
        System.out.println("**********拓展类加载器**********");
        String extDirs = System.getProperty("java.ext.dirs");
        for (String path : extDirs.split(";")) {
            System.out.println(path);
        }

        //从上面的路径中随意选择一个类，来看看他的类加载器是什么: 拓展类加载器
        ClassLoader classLoader = CurveDB.class.getClassLoader();
        System.out.println(classLoader);
    }
}

在这里插入图片描述

1.3，应用程序类加载器（系统类加载器，AppClassLoader）

  • java语言编写，有sun.misc.Launcher$AppClassLoader实现；
  • 派生于ClassLoader类；
  • 父类加载器为拓展类加载器；
  • 它负责加载环境变量classpath或系统属性java.class.path指定路径下的类库；
  • 该类加载器是程序中默认的类加载器，一般来说，Java应用的类都是由它来完成加载；
  • 通过ClassLoader#getSystemClassLoader()方法可以获取到该类加载器。

2，自定义类的加载器

在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的，在必要时，我们还可以自定义类加载器，来定制类的加载方式。

2.1，为什么要自定义类的加载器？

  • 隔离加载类，避免类的冲突
  • 修改类加载的方式
  • 拓展加载源
  • 防止源码泄露

2.2，自定义类加载器实现步骤

  1. 开发人员可以通过继承抽象类java.lang.ClassLoader类的方式，实现自己的类加载器，以满足一些特殊的需求；
  2. 在JDK1.2之前，在自定义类加载器时，总会去继承ClassLoader类并重写loadClass()方法，从而实现自定义的类加载器，但是在JDK1.2之后已不再建议用户去覆盖loadClass()方法，而是建议把自定义的类家在逻辑写在findClass()方法中；
  3. 在编写自定义类加载器时，如果没有太过于复杂的需求，可以直接继承URLClassLoader类，这样就可以避免自己去编写findClass()方法及其获取字节码流的方式，使自定义类加载器编写更加简洁。
    如下实例：
package com.drhj;

import java.io.FileNotFoundException;

/**
 * Author: DRHJ
 * Date: 2022/10/20 22:39
 * 用户自定义加载器
 */
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 {
                    return defineClass(name, result, 0, result.length);
                }
        } catch (Exception e) {
            e.printStackTrace();
        }

        throw new ClassNotFoundException(name);
    }

    private byte[] getClassFromCustomPath(String name) {
        //从自定义路径中加载指定类:细节略
        return null;
    }

}

四，ClassLoader的常用方法及获取方法

ClassLoader类，它是一个抽象类，其后所有的类加载器都继承自ClassLoader（不包括启动类加载器）

方法名称描述
getParent()返回该类加载器的超类加载器
loadClass(String name)加载名称为name的类，返回结果为java.lang.Class类的实例
findClass(String name)查找名称为name的类，返回结果为java.lang.Class类的实例
findLoadedClass(String name)查找名称为name的已经被加载过的类，返回结果为java.lang.Class类的实例
defineClass(String name, byte[] b, int off, int len)把字节数组b中的内容转换为一个Java类，返回结果为java.lang.Class类的实例
resolveClass(Class<?> c)连接指定的一个Java类
方法名称描述
clazz.getClassLoader()获取当前类的ClassLoader
Thread.currentThread().getContextClassLoader()获取当前线程上下文的ClassLoader
ClassLoader.getSystemClassLoader()获取系统的ClassLoader
DriverManager.getCallerClassLoader()获取调用者的ClassLoader
package com.drhj;

import java.sql.DriverManager;

/**
 * Author: DRHJ
 * Date: 2022/10/22 13:57
 */
public class ClassLoaderTest2 {
    public static void main(String[] args) {
        try {
            ClassLoader classLoader1 = Class.forName("java.lang.String").getClassLoader();
            System.out.println(classLoader1);

            ClassLoader classLoader2 = Thread.currentThread().getContextClassLoader();
            System.out.println(classLoader2);

            ClassLoader classLoader3 = ClassLoader.getSystemClassLoader();
            System.out.println(classLoader3);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

五，双亲委派机制

Java虚拟机对class文件采用的是按需加载的方式，也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象。而且加载某个类的class文件时，Java虚拟机采用的是双亲委派模式，即把请求交由父类处理，它是一种任务委派模式。

1，一个现象

我们在自己的项目中的src下创建一个名为 java.lang文件夹，然后创建String类，如下：

package java.lang;

/**
 * Author: DRHJ
 * Date: 2022/10/22 14:13
 */
public class String {
    static {
        System.out.println("我是自定义的String类的静态代码块");
    }
}

再编写方法创建String对象，如下：

package com.drhj.java;

/**
 * Author: DRHJ
 * Date: 2022/10/22 14:14
 */
public class StringTest {
    public static void main(String[] args) {
        String str = new String();
        System.out.println("hello, drhj");
    }
}

如果这个String对象是我们创建的String对象，由于我们创建对象中含有静态代码块，所以必然会打印出“我是自定义的String类的静态代码块”的字样
在这里插入图片描述
但实际结果并没有，为什么？
双亲委派机制

2，工作原理

在这里插入图片描述

  1. 如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行；
  2. 如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器；
  3. 如果父类加载器可以完成加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式。

所以上述的例子，String任然是引导类加载的String对象，也就是j加载了jdk中自带的String类，而并非我们创建的类。

package com.drhj.java;

/**
 * Author: DRHJ
 * Date: 2022/10/22 14:14
 */
public class StringTest {
    public static void main(String[] args) {
        String str = new String();
        System.out.println("hello, drhj");
        System.out.println(str.getClass().getClassLoader());
    }
}

在这里插入图片描述
当我们在自己创建的String对象中写一个main方法并执行，那必然也是无法执行的，因为加载的是自带的String，是没有main方法的

package java.lang;

/**
 * Author: DRHJ
 * Date: 2022/10/22 14:13
 */
public class String {
    static {
        System.out.println("我是自定义的String类的静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("hello, String");
    }
}

在这里插入图片描述

3，加载SPI接口

SPI接口可以理解为第三方接口，比如jdbc这些
在这里插入图片描述

  1. SPI接口属于核心的的API，通过双亲委派机制到引导类加载器加载核心jar包，将SPI核心类加载出来；
  2. 这里面会存在接口的实现类，因为属于第三方了，不属于核心的API，所以反向委派，一直到系统类加载器（实际上就是当前线程的上下文类加载器）进行加载。

4，优势

  • 避免类的重复加载
  • 保护程序安全，防止核心API被随意篡改
package java.lang;

/**
 * Author: DRHJ
 * Date: 2022/10/22 14:45
 */
public class DrhjStart {
    public static void main(String[] args) {
        System.out.println("hello, drhj");
    }
}

在这里插入图片描述
为了安全，禁止java.lang这类文件夹开头的类

5，沙箱安全机制

自定义String类，但是在加载自定义String类的时候会率先使用引导类加载器加载，而引导类加载器在加载的过程中会先加载jdk自带的文件（rt.jar包中java\lang\String.class），报错信息说没有main方法，就是因为加载的是rt.jar包中的String类。这样可以保证对java核心源代码的保护，这就是沙箱安全机制。

六，其他

1，在JVM中表示两个class对象是否为同一个类存在两个必要条件：

  • 类的完整路径名必须一致，包括包名
  • 加载这个类的ClassLoader（指ClassLoader实例对象）必须相同

换句话说，在JVM中，即使这两个类对象（class对象）来源同一个Class文件，被同一个虚拟机所加载，但只要加载它们的ClassLoader实例对象不同，那么这两个类对象也是不相同的。

2，对类加载器的引用

JVM必须知道一个类型是由启动加载器加载的还是由用户加载器加载的。如果一个类型是由用户类加载器加载的，那么JVM会将这个类加载器的一个引用作为类型信息的一部分保存在方法区中。当解析一个类型到另一个类型的引用的时候，JVM需要保证这两个类型的类加载器是相同的。

3，类的主动使用和被动使用

Java程序对类的使用方式分为：主动使用和被动使用
主动使用又分为七种情况：

  • 创建类的实例
  • 访问某个类或接口的静态变量，或者对该静态变量赋值
  • 调用类的静态方法
  • 反射（比如：Class.forName(“xxx”)）
  • 初始化一个类的子类
  • Java虚拟机启动时被标明为启动类的类
  • JDK 7 开始提供的动态语言支持：java.lang.invoke.MethodHandle实例的解析结果 REF_getStatic，REF_putStatic，REF_invokeStatic句柄对应的类没有初始化，则初始化。

除了以上七种情况，其他使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化。

DRHJ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JVM组成部分-类加载子系统、类加载器
COCO33333的博客
12-07 130
JVM组成部分-类加载子系统、类加载器及面试问题
【JVM】类加载系统
weixin_45105179的博客
09-22 260
类加载器
【JVM】类加载器子系统
比尔高特的博客
09-24 100
jvm，类加载器子系统，Java类的加载过程，双亲委派机制
JVM 从入门到精通（三）类加载子系统
云祁QI
06-06 692
文章目录一、内存结构概述二、类加载器和类的加载过程2.1 类加载子系统作用2.2 类加载器ClassLoader角色2.3 类的加载过程2.3.1 加载2.3.2 链接（即验证、准备、解析）2.3.3 初始化三、类加载器分类4.1 自定义类与核心类库的加载器4.2 虚拟机自带的加载器3.3 用户自定义加载器四、ClassLoader的使用说明五、双亲委派机制 一、内存结构概述 复杂版的详细图 本文针对Class Loader SubSystem这一块展开讲解类加载子系统的工作流程。 如果自己手写一个Ja
《JVM系列》 第二章 -- 类加载器子系统_扩展机制 启动前通过什么方法添加自定义类转换器 实现在类加载前实现字节码
最新发布
chanter4的博客
04-21 551
JVM的由以下几部分组成：Java的动态类加载功能由ClassLoader子系统处理。它加载，链接。并在运行时（而非编译时）首次引用类时初始化类文件。Java虚拟机在执行Java程序的过程中会把它管理的内存分为若干个不同的数据区域。分配给运行时数据区的字节码将由执行引擎执行，执行引擎读取字节码并逐段执行。JNI将与本机方法库进行交互，并提供执行引擎所需的本机库本机库的集合，执行引擎执行时需要千千万万要记得：多刷题！！多刷题！！
JVM——类加载子系统
chenxingxingxing的博客
10-21 869
其它几种类型类加载器都可以获取到父类加载器，由上面包含关系可以看出，扩展类加载器父加载器是引导类加载器，系统类加载器父类是扩展类加载器，而用户自己编写类的是通过系统类加载器加载。类的加载一般依靠引导类、扩展类、系统类相互配合执行，在特定场合下，开发人员可以自己定义类的加载器。在字节码文件中，一个类的方法会被解析到methods文件目录下，构造器对应目录下的()方法, main()就对应main()。JVM支持两种类型类加载器，分别为引导类加载器和自定义类加载器。
JVM之类加载子系统
Sumuxi9797926的博客
01-31 382
在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器互相配合执行的，在必要时，我们还可以自定义类加载器，来定制类的加载方式。用户自定义类加载器实现步骤：1、开发人员可以通过继承抽象类java.lang.ClassLoader类的方式，实现自己的类加载器，以满足一些特殊的需求；
JVM—类加载子系统
qq_52896771的博客
03-03 376
1.对于用户自定义类来说：将使用系统类System Class Loader加载器中的AppClassLoader进行加载2.java核心类库都是使用引导类加载器BootStrapClassLoader加载的/*** ClassLoader加载//获取系统类加载器 ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
02 类加载子系统.pptx
06-15
02 类加载子系统 PPT 介绍 JVM 的类加载子系统, 包括类加载阶段和流程、加载器分类和类加载机制等。
JVM解毒——类加载子系统
01-20
带着问题，尤其是面试问题的...类加载子系统 类加载机制概念 Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的加载机制
JVM类加载机制详解
08-31
当Java程序启动时，JVM首先会查找JRE目录下的jvm.dll，初始化JVM，然后依次创建Bootstrap Loader、Extended Loader（标准扩展类加载器）和AppClass Loader（系统类加载器）。Bootstrap Loader是最顶层的加载器，它的...
JVM类加载过程.pptx
05-07
JVM主要组成部分包括类加载子系统、执行引擎、本地方法接口和运行时数据区。 类加载子系统是JVM的核心组件之一，它负责加载字节码文件到运行时数据区的方法区。类加载器（ClassLoader）将字节码文件加载到内存中，...
Java ---JVM之类加载子系统
qq_46093575的博客
09-24 747
④、解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等。除了类的信息外，方法区中还会存放运行时常量池信息，可能还包括字符串字面量和数字常量（这部分常量信息是Class文件中常量池部分的内存映射)。1、class file 存在于本地硬盘上，可以理解为设计师画在纸上的模板，而最终这个模板在执行的时候是要加载到JVM当中来根据这个文件实例化出n个一模一样的实例。3、在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
【进行中，随时弃坑】简易JVM的C++实现
一条咸鱼的博客
07-02 1273
源码地址：https://pan.baidu.com/s/1Jj1H5uL3RLDzZARxFD0Bfw 提取码：68x7 2019.07.04更新 一、想法： 暑假闲着也是闲着，不如做一些有趣的事情，所以我决定做一个简易的java虚拟机。其实真的是心血来潮，因为几天前我在找关于java虚拟机学习资料的时候无意间发现了一本书——《自己动手写java虚拟机》。哇，手写jvm，这也太酷了...
类加载子系统
weixin_48206782的博客
09-14 123
类加载子系统
windows系统使用c++实现一个小型jvm(三)------------jvm的启动细节2
automannn
03-08 420
这篇文章接着上午记录下。 1.标准输入输出流是怎么来的？ 在写java程序的时候，我们经常输出控制台信息，调用的如下代码： System.out.Println(); 在这里，我将解释这个的由来。 jvm在初始化时，必须先加载FileDescriptor，FileDescriptor有三个静态成员： 它们会调用本地FileDescriptor的SetI方法： ...
windows系统使用c++实现一个小型jvm(一)------------环境介绍及背景说明
automannn
03-07 593
背景说明： 首先，本个小demo并不是我自己写的，说是小demo，实际也不小，总共的代码量有3兆多了。原创的大牛在这儿-----用 C++ 实现了一个小型的 jvm！！！！ 当我看到这个贴子时候以及它的代码量之后，心里是既高兴，又犹豫的。 为什么呢？ 高兴是因为，没想到能够有机会接触这么底层的东西，当把它吃透后，想想自己的java造诣也能再进一步吧，同时也能呼应上一篇文章...
jvm类加载子系统有什么作用
04-21
JVM类加载子系统的主要作用是从文件系统或网络中加载需要运行的Java类，并在运行时为它们创建Java对象。它还负责解析类的依赖关系，并在需要时动态地链接它们。此外，JVM类加载子系统还提供安全机制，以确保只有授权...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值