【JVM系列】深入理解Java虚拟机（JVM）的核心技术：从加载到初始化的全过程解析(一、Java类加载器)

于 2024-10-08 07:00:00 发布
阅读量603 收藏 13
点赞数 11
分类专栏： JVM 文章标签： JVM Java虚拟机 HotSpot 类加载器 SPL 双亲委派 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68020300/article/details/142708128
版权

文章目录

【JVM系列】深入理解Java虚拟机（JVM）的核心技术：从加载到初始化的全过程解析(一、Java类加载器)

类加载器（Class Loader）是Java运行时环境中一个重要的组件，它负责在程序运行期间动态地加载类文件到Java虚拟机（JVM）中。类加载器不仅能够从本地文件系统加载类，也可以从网络或者其他自定义的存储位置加载类。这样的设计使得Java程序具有高度的灵活性和扩展性。

1. 类加载器加载的过程

类加载器在Java虚拟机（JVM）中负责加载类文件到内存中，并且进行相应的验证、准备和初始化工作。整个过程可以分为以下几个阶段：

1. 加载（Loading）

在这个阶段，类加载器会根据指定的类全名（包括包名）来查找并加载该类的二进制字节流。这个二进制字节流通常来自于.class文件，但也可以来自其他地方，例如数据库、网络资源等。加载完成后，类加载器会在内存中生成一个java.lang.Class对象，表示这个类。

2.验证（Verification）

验证阶段的主要目的是确保读入的字节流包含的信息符合JVM规范的要求，不会危害到虚拟机自身的安全。验证过程包括四个子阶段：文件格式验证、元数据验证、字节码验证和符号引用验证。

  • 文件格式验证：确保输入的字节流能正确地解析并符合Class文件格式的规范。
  • 元数据验证：对类的方法和字段根据Java语言规范进行语义验证。
  • 字节码验证：进行数据流和控制流分析，确保程序不会做出危害虚拟机安全的行为。
  • 符号引用验证：确保解析后的类的方法区的常量池里的各种符号引用可以成功地解析成具体的类、接口、字段和方法。

3.准备（Preparation）

准备阶段负责为类的静态变量分配内存，并设置类变量（即static修饰的变量）所需的初始值，这与程序代码无关，而是根据字段的数据类型和是否有显式初始化来决定的。例如所有的基本类型的字段会被初始化为零值（如0、0L、false、null等）。

4.解析（Resolution）

解析阶段是将类的二进制数据中的符号引用替换为直接引用的过程。符号引用就是符号名加上描述符组成的字符串，而直接引用则是可以直接定位到内存地址的指针、相对偏移量或是一个能够间接定位到目标的句柄。

5.初始化（Initialization）

初始化阶段是执行类构造器<clinit>()方法的过程。<clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序按照文本顺序排列。<clinit>()方法对于类或接口来说并不是必须的，如果一个类中没有静态语句块，也没有对类变量的赋值操作，那么编译器就可以不为这个类生成<clinit>()方法。

类的初始化还包括了其父类的初始化，如果类中有静态初始化块，则静态初始化块也会被执行。

需要注意的是，虽然类加载的过程通常按照上述顺序进行，但在某些情况下，例如在某些验证子阶段之间可能会有交叉行为，不是完全线性的。此外，类加载的具体实现细节可能因不同的JVM实现而有所不同。

2. Class文件读取来源

  1. 本地磁盘文件 java源代码编译的class文件

  2. 通过网络下载的class文件

  3. War、Jar解压的class文件

  4. 从专门的数据库中读取的class文件

  5. 使用java cglib、动态代理生成的代理类class文件

3. 类加载器的分类

  1. 启动（Bootstrap）类加载器：加载JVM自身工作需要的类，它由JVM自己实现。它会加载$JAVA_HOME/jre/lib下的文件 底层是C语言实现

  2. 扩展（Extension）类加载器：它是JVM的一部分，由sun.misc.LauncherExtClassLoader实现，他会加载ExtClassLoader实现，他会加载ExtClassLoader实现，他会加载JAVA_HOME/jre/lib/ext目录中的文件（或由System.getProperty(“java.ext.dirs”)所指定的文件）。 底层是Java实现

  3. （应用）AppClassLoader 类加载器：应用类加载器，我们工作中接触最多的也是这个类加载器，它由sun.misc.Launcher$AppClassLoader实现。他加载我们工程目录classpath下的class及jar包，底层是java实现

  4. 自定义类加载器： 也就是用户自己定义的类加载器

image-20240912212021198 
import java.util.Arrays;
import java.util.List;

public class JvmDemo01 {
    public static void main(String[] args) {
        // 应用类加载器
        bootstrapClassLoader();
        System.out.println("------------------------------");
        extClassLoader();
        System.out.println("------------------------------");
        appClassLoader();
    }

    /**
     * 启动类加载器的职责
     */
    public static void bootstrapClassLoader() {
        String property = System.getProperty("sun.boot.class.path");
        List<String> list = Arrays.asList(property.split(";"));
        list.forEach((t) -> {
            System.out.println("启动类加载器目录:" + t);
        });
    }


    /**
     * 扩展类加载器
     */
    public static void extClassLoader() {
        String property = System.getProperty("java.ext.dirs");
        List<String> list = Arrays.asList(property.split(";"));
        list.forEach((t) -> {
            System.out.println("扩展类加载器" + t);
        });
    }

    /**
     * app 类加载器
     */
    public static void appClassLoader() {
        String property = System.getProperty("java.class.path");
        List<String> list = Arrays.asList(property.split(";"));
        list.forEach((t) -> {
            System.out.println("应用类加载器" + t);
        });
    }
}

4. 那些操作会初始化类加载器

类的主动使用：

  1. 调用类的静态方法
  2. invokeStatic 调用静态方法
  3. Main
  4. new
  5. Class.formname
  6. 子类初始化一定会初始化父类

初始化一个类，那么一定会触发类加载器；但是类加载器加载了该类，但是该类不一定初始化。

5. 类加载器的双亲委派机制

首先在我们类加载器分为四种自定义类加载器、应用类加载器、扩展类加载器、启动类加载器。

当一个类加载器收到请求之后，首先会依次向上查找到最顶层类加载器（启动类加载器），依次向下加载class文件，如果已经加载到class文件，子加载器不会加继续加载该class文件。

**双亲委派机制机制的好处：**目的就是为了防御开发者为定义的类与jdk定义源码类产生冲突问题，保证该类在内存中的唯一性。

6. ClassLoader源码解读

6.1 Launcher类源码解读

public class JvmDemo02 {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        Class<?> aClass = ClassLoader.getSystemClassLoader().loadClass("com.zhaoli.jvm.test01.JvmDemo01");
        Object o = aClass.newInstance();
        System.out.println(o.getClass().getClassLoader());
    }
}

public abstract class ClassLoader {
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }

    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {  // 确保类加载的线程安全性
            // 首先检查该类是否已经被加载过
            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异常，则说明父类加载器未能找到该类
                    // ClassNotFoundException thrown if class not found from the non-null parent class loader
                }

                if (c == null) {  // 如果此时类仍然未被加载
                    // 调用findClass方法来寻找该类
                    long t1 = System.nanoTime();  // 记录调用findClass的时间点
                    c = findClass(name);  // 这里是由当前类加载器自己去查找并加载类

                    // 当前类加载器是定义类的加载器；记录相关统计信息
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }

            if (resolve) {  // 如果需要解析类，则调用resolveClass方法来解析类
                resolveClass(c);
            }
            return c;  // 返回加载好的类
        }
    }

    private Class<?> findBootstrapClassOrNull(String name) {
        if (!checkName(name)) return null;  // 检查类名是否合法，如果不合法则返回null

        // 尝试通过启动类加载器来加载类
        return findBootstrapClass(name);
    }

    // 如果找不到指定的类，则返回null
    private native Class<?> findBootstrapClass(String name);
}

代码为Class<?> aClass = ClassLoader.getSystemClassLoader().loadClass("com.zhaoli.jvm.test01.JvmDemo01");

  1. 先进入loadClass()

    • 发现此类没有被加载过
    • 存在父类加载器继续调用loadClass()让父类加载器加载
    • 循环（发现此类没有被加载过）（自动向上依次检查是否已经被加载过）
    • 存在父类加载器继续调用loadClass()（让父类加载器加载）直到没有父类加载器
    • 调用findBootstrapClassOrNull()尝试加载核心类库中的类
    • 发现没有（if (c == null)）则（自定向下依次加载）调用findClass()(此时是扩展类加载器)查找此类
    • 返回上一级的loadClass()方法，发现没有（if (c == null)）则（自定向下依次加载）调用findClass()(此时是应用类加载器)查找此类
    • 最终找到此类（是应用类加载器）找到的

  2. 当我们将com.zhaoli.jvm.test01.JvmDemo01类对应的class类拷贝到D:\Java\jdk1.8\jre\目录下（注意并不是直接拷贝JvmDemo01.class而是拷贝整个文件夹target/classes/com/zhaoli/jvm/test01/JvmDemo01.class）

    • 此时先进入loadClass()
    • 发现此类没有被加载过
    • 存在父类加载器继续调用loadClass()让父类加载器加载
    • 循环（发现此类没有被加载过）（自动向上依次检查是否已经被加载过）
    • 存在父类加载器继续调用loadClass()（让父类加载器加载）直到没有父类加载器
    • 调用findBootstrapClassOrNull()尝试加载核心类库中的类
    • 不进入if (c == null)（此时是启动类加载器）
    • 不进入if (c == null)（此时是应用类加载器）
    • 最终找到此类（是启动类加载器）找到的

代码为：Class<?> aClass = ClassLoader.getSystemClassLoader().loadClass("java.lang.Stirng");

  • 先进入loadClass()=>发现此类被加载过（Stirng提前已经加载过了）=>直接返回

6.2 自定义一个类加载器

public class TestClassLoader extends ClassLoader {

    private File fileObject;

    public TestClassLoader(File fileObject) {
        this.fileObject = fileObject;
    }

    public void setFileObject(File fileObject) {
        this.fileObject = fileObject;
    }

    public File getFileObject() {
        return fileObject;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] data = getClassFileBytes(this.fileObject);
            System.out.println("进入到了自定义类加载器（TestClassLoader）的 findClass() 来加载 class 类");
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }

    /**
     * 从文件中读取去class文件
     */
    private byte[] getClassFileBytes(File file) throws Exception {
        //采用NIO读取
        FileInputStream fis = new FileInputStream(file);
        FileChannel fileC = fis.getChannel();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        WritableByteChannel outC = Channels.newChannel(baos);
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        while (true) {
            int i = fileC.read(buffer);
            if (i == 0 || i == -1) {
                break;
            }
            buffer.flip();
            outC.write(buffer);
            buffer.clear();
        }
        fis.close();
        return baos.toByteArray();
    }
}

public class JvmDemo03 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        TestClassLoader testClassLoader = new TestClassLoader(new File("D:\\code\\Test01.class"));
        Class<?> aClass = testClassLoader.loadClass("com.zhaoli.jvm.test01.Test01");
        Object o = aClass.newInstance();
        System.out.println(o);
    }
}

7. 根据类加载器手写热部署插件

  1. 如何判断一个class 文件是否发生变化? MD5或者操作系统提供api 文件修改时间

  2. 判断该class文件修改日期是否有发生变化，如果有发生变化，则从新使用类加载器读取最新的class文件到内存中。

  3. 如何监听class文件是否有发生变化呢?单独线程

public class ClassFileEntity {

    /**
     * 类的名称
     */
    private String name;

    /**
     * class
     */
    private Class aClass;

    /**
     * 最后被更改的时间
     */
    private long lastModified;

    public ClassFileEntity(String name, long lastModified) {
        this.name = name;
        this.lastModified = lastModified;
    }

    public ClassFileEntity(String name, long lastModified, Class aClass) {
        this.name = name;
        this.lastModified = lastModified;
        this.aClass = aClass;
    }
	//此处省略get()和set()
}

@Slf4j
public class HotDeploymentPlug {
    //存放所有的class文件
    private Map<String, ClassFileEntity> mapClassFiles = new HashMap<>();
    private String path;
    /**
     * 包的名称
     */
    private String packageName = "com.zhaoli.demo.";

    public HotDeploymentPlug(String path) {
        this.path = path;
    }

    public void start() {
        listener();
    }

    /**
     * 监听方法
     */
    public void listener() {
        new Thread(() -> {
            while (true) {
                // 1.读取该文件下
                File files = new File(path);
                File[] tempList = files.listFiles();
                // 2.读取class文件 存入到 mapClassFiles
                for (File file : tempList) {
                    String name = file.getName();
                    if (StringUtils.isEmpty(name)) {
                        continue;
                    }
                    long l = file.lastModified();
                    // 使用类加载器读取该 class
                    String className = packageName + name.replace(".class", "");
                    if (mapClassFiles.containsKey(className)) {
                        // 则比对该class文件 是否被修改
                        ClassFileEntity mapClassFileEntity = mapClassFiles.get(className);
                        if (mapClassFileEntity.getLastModified() != l) {
                            try {
                                mapClassFileEntity.setLastModified(l);
                                TestClassLoader testClassLoader = new TestClassLoader(file);
                                Class<?> aClass = testClassLoader.loadClass(className);
                                Object o = aClass.newInstance();
                                log.info(className + "class文件发生了变化");
                            } catch (Exception e) {
                                log.error("e:{}", e);
                            }
                        }
                    } else {
                        ClassFileEntity newClassFileEntity = new ClassFileEntity(className, l);
                        // 如果不存在 则存入到mapClassFiles集合中
                        mapClassFiles.put(className, newClassFileEntity);
                    }
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        }).start();
    }
}

public static void main(String[] args) {
    HotDeploymentPlug hotDeploymentPlug = new HotDeploymentPlug("D:\\code\\com\\zhaoli\\demo");
    hotDeploymentPlug.listener();
}

8. SPI机制

SPI 机制（Service Provider Interface）是 Java 中的一种服务发现机制，用于在运行时动态加载和使用类库中的服务实现。SPI 机制允许开发者定义服务接口，并让不同的服务提供者提供自己的实现，而不必修改原始代码或重新编译。

SPI 机制的基本原理：

  1. 服务接口定义：开发者首先定义一个服务接口（通常是一个抽象类或接口），这个接口声明了服务应提供的方法。

  2. 服务实现：第三方开发者可以提供这个接口的具体实现类。这些实现类通常放在项目的类路径下的某个包内。

  3. 配置文件：实现类的信息记录在一个名为 services 目录下的文本文件中，文件名是服务接口的全限定名（包名+类名）。每个文件包含一行或多行，每行对应一个实现类的全限定名。

  4. 加载实现类：当应用程序启动时，JVM 会查找并加载这些配置文件，并根据配置文件中的信息实例化相应的服务实现类。

示例：

假设有一个服务接口 com.example.MyService，并且有两个实现类 com.example.impl.MyServiceImpl1 和 com.example.impl.MyServiceImpl2。

配置文件内容：

在 src/main/resources/META-INF/services/com.example.MyService 文件中，内容如下：

com.example.impl.MyServiceImpl1
com.example.impl.MyServiceImpl2

加载实现类：

当应用程序需要使用 MyService 接口的服务时，可以通过以下代码加载实现类：

import java.util.ServiceLoader;

public class ServiceProviderDemo {
    public static void main(String[] args) {
        ServiceLoader<MyService> loader = ServiceLoader.load(MyService.class);
        for (MyService service : loader) {
            System.out.println("Loaded service implementation: " + service.getClass().getName());
            // 调用服务实现的方法
            service.doSomething();
        }
    }
}

SPI 机制的优点：

  1. 扩展性：无需修改源代码即可添加新的服务实现。

  2. 灵活性：可以在运行时动态加载不同的服务实现。

  3. 插件式架构：适合构建插件式的架构，允许第三方扩展核心功能。

SPI 机制的局限性：

  1. 静态加载：SPI 机制在类加载时就会加载所有实现类，无法在运行时动态注册或卸载服务。

  2. 单一实例：SPI 默认为每个服务提供者创建一个单例对象，如果服务实现依赖于外部状态或其他初始化参数，可能需要额外的处理。

  3. 线程安全：如果有多个实现类，SPI 机制需要保证线程安全，否则可能会出现并发问题。

9. 如何绕开双亲委派原则

双亲委派模型（Parent Delegation Model）是 Java 类加载器体系结构的核心组成部分。在这个模型中，每个类加载器负责先将其加载请求委托给父类加载器，只有当父类加载器无法完成加载请求时，才会尝试自己加载。这种机制有助于确保类的一致性和避免类加载冲突。

**绕开双亲委派模型的方法：**绕开双亲委派模型通常意味着你需要自定义类加载器，并且在某些情况下直接加载类而不经过标准的委托流程。以下是一些常见的方法：

1. 自定义类加载器

你可以创建一个自定义的类加载器，覆盖 findClass() 方法，并且在 loadClass() 方法中不调用 super.findClass()，而是直接加载类。这样就可以绕过标准的委托机制。

import java.io.InputStream;

public class CustomClassLoader extends ClassLoader {
    private final String name;
    private final byte[] classData;

    public CustomClassLoader(String name, byte[] classData) {
        this.name = name;
        this.classData = classData;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        return defineClass(name, classData, 0, classData.length);
    }

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (name.equals(this.name)) {
            return findClass(name);
        } else {
            return super.loadClass(name); // 这里仍然可以调用父类加载器
        }
    }
    
    // 其他必要的方法，如getResourceAsStream等
}

2. 使用 defineClass() 方法

你可以使用 ClassLoader 的 defineClass() 方法来直接定义类，而不是通过标准的类加载流程。这种方式通常用于从字节数组中加载类，例如从网络、磁盘或者其他来源获取的字节码数据。

public class CustomClassLoader extends ClassLoader {
    public Class<?> defineClass(byte[] classData) {
        return defineClass("CustomClassName", classData, 0, classData.length);
    }
}

3. 使用 ClassLoader.defineClass(String name, byte[] b) 方法

这种方法直接使用 ClassLoader 类的静态方法来定义类，这种方式不依赖于类加载器的继承关系。

public class CustomClassLoader extends ClassLoader {
    public Class<?> defineClass(byte[] classData) {
        return defineClass("CustomClassName", classData, 0, classData.length);
    }
}

注意事项：

  1. 安全性：绕过双亲委派模型可能会导致安全性和一致性问题，特别是当涉及到核心类库的加载时。

  2. 兼容性：如果你的类加载逻辑过于复杂，可能会导致与其他框架或库的兼容性问题。

  3. 维护性：自定义类加载器增加了系统的复杂性，可能会使代码更难以维护。

10. 常见的几款java虚拟机

Java 虚拟机（JVM）是 Java 运行时环境的核心组件，它负责执行 Java 字节码。不同的 JVM 实现有不同的特性和适用场景。以下是几种常见的 Java 虚拟机：

  1. Oracle HotSpot VM：HotSpot 是最常用的 Java 虚拟机，由 Sun Microsystems 开发（后来被 Oracle 收购）。HotSpot VM 是 OpenJDK 和 Oracle JDK 的默认 JVM，它具有以下特点：

    • 性能优化：HotSpot 包含了许多性能优化技术，如即时编译（JIT）、垃圾回收（GC）算法等。

    • 开源：HotSpot 是 OpenJDK 项目的一部分，因此它是开源的。

    • 广泛支持：几乎所有的现代 Java 开发环境都支持 HotSpot。

  2. OpenJ9：OpenJ9 是 IBM 开发的一款高性能的 Java 虚拟机，现在由 Eclipse 基金会维护。OpenJ9 作为 IBM 的 Java SE 8 和 Java SE 11 发布版的基础，并且也被用于 Adoptium（之前称为 AdoptOpenJDK）项目中。OpenJ9 的特点包括：

    • 内存效率：OpenJ9 通常具有较低的内存使用。

    • 性能：在某些工作负载下，OpenJ9 表现出色，尤其是那些需要长时间运行的应用程序。

    • 可移植性：OpenJ9 支持多种操作系统和硬件平台。

  3. GraalVM：GraalVM 是 Oracle 开发的一款多语言虚拟机，支持 Java、JavaScript、Python、Ruby 等多种语言。GraalVM 的特点是：

    • 多语言支持：除了 Java，还支持其他动态语言。

    • AOT 编译：支持提前编译（Ahead-of-Time Compilation），可以将 Java 字节码转换为本地代码，提高启动速度和运行时性能。

    • 内存效率：GraalVM 通常具有较好的内存效率。

  4. Zing：Zing 是 Azul Systems 开发的一款企业级 Java 虚拟机，专为大规模、长时间运行的应用程序设计。Zing 的特点包括：

  5. Zulu：Zulu 是 Azul Systems 提供的一款开源 Java 虚拟机实现，基于 OpenJDK。Zulu 支持多种 Java 版本，并且是完全免费和开源的。

无理 Java
关注
专栏目录
Java虚拟机JVM类加载初始化
10-03
Java虚拟机JVM类加载初始化是Java程序运行过程中的关键环节，它负责将类的字节码文件加载到内存中并进行相应的处理，以便程序能够正确执行。在Java中，类加载器（Classloader）扮演着核心角色。下面将详细讨论类加载...
解析Java虚拟机中类的初始化及加载器的父委托机制共14页
10-31
Java虚拟机（JVM）是Java程序运行的核心，它的内部机制包括了类的加载、链接、初始化等关键过程。在Java编程中，了解这些过程对于优化程序性能、理解和解决类加载问题至关重要。本文将深入探讨Java虚拟机中的类初始...
深入理解 Java 虚拟机（JVM）从入门到精通
一名后端程序猿
12-06 2559
这篇博客将全面介绍Java虚拟机（JVM）的核心概念，从运行时数据区域到性能优化策略，内容涵盖丰富。首先将深入探讨JVM的运行时数据区域，包括堆、栈、方法区等，为读者提供全面的理解。其次，我们将分享优化Java应用性能的方法，讨论JVM调优和垃圾回收策略，帮助开发人员在实践中提高代码效率。
【深入理解java虚拟机】 - JVM类的加载过程
1+1=王的博客
07-15 6843
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最 终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。一个类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期将会经历加载 （Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化 （Initialization）、使用（Using）和卸载（Unloading） 七个阶段，其中验证、准备、解析三个部分统称为链接（L
Java 入门指南：JVM（Java虚拟机）——类的生命周期与加载过程
Zachyy的博客
09-15 1541
类从被加载到虚拟机内存中开始到卸载出内存为止，它的整个生命周期可以简单概括为 7 个阶段：加载、验证、准备、解析、初始化、使用和卸载。其中，验证、准备和解析这三个阶段可以统称为连接。 的生命周期除去使用和卸载，就是 Java 的类加载过程。这 5 个阶段一般是顺序发生的，但在动态绑定的情况下，解析阶段发生在初始化阶段之后。系统加载 Class 类型的文件主要三步：加载->连接->初始化。连接过程又可分为三步：验证->准备->解析。
Java虚拟机（JVM）你只要看这一篇就够了！
热门推荐
Java笔记
08-14 72万+
1. Java 内存区域与内存溢出异常 1.1 运行时数据区域 根据《Java 虚拟机规范(Java SE 7 版)》规定，Java 虚拟机所管理的内存如下图所示。 1.1.1 程序计数器 内存空间小，线程私有。字节码解释器工作是就是通过改变这个计数器的值来选取下一条需要执行指令的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖计数器完成 如果线程正...
深入剖析Java虚拟机（JVM）：工作原理、内存管理与优化全解析
qq_44664868的博客
04-04 1237
一、引言（Java Virtual Machine，简称JVM）是运行Java程序的抽象计算机，是Java语言的运行环境。它提供了Java程序运行所需的内存管理、垃圾收集、类加载等核心功能。理解JVM对于Java开发人员来说至关重要，它有助于我们优化程序性能、解决内存泄漏等问题。
深入理解Java虚拟机：Jvm性能调优
栗筝i的博客
11-06 4773
本篇内容包括：Jvm 性能调优简介；根据需求目标进行 Jvm 调优规划（即 调优的目标、调优的步骤）；Jvm 调优参数、命令、工具；以及 Java 中的内存泄露问题的详解...
深入理解Java虚拟机jvm-类加载步骤
小蜗牛的博客
09-29 1528
jvm-类加载步骤
深入理解Java虚拟机1：类加载器深入解析与阶段分解&类的加载、连接与初始化过程详解
YonminMa的博客
02-24 1981
文章目录类加载类加载器类的使用与卸载*类的加载、连接与初始化类的加载 类加载 在Java代码中，类型（Class）的加载、连接与初始化过程都是在程序运行期间（而不是编译期间）完成的。此特点提供了更大的灵活性，增加了更多的可能性。 类加载器 类加载器为用来加载类的工具。 在如下情况下，Java虚拟机将结束生命周期 执行了 System.exit()方法； 程序正常执行结束； 程序在执行过程中遇到了...
Java类加载机制的几个个阶段，加载、验证、准备、解析、初始化【jvm】
qq_46489085的博客
01-12 3854
类加载阶段 1、加载 概述： 一个Java文件从编码完成到最终执行，一般主要包括两个过程：编译和运行，其中编译就是把我们写好的java文件，通过javac命令编译成字节码，也就是我们常说的.class文件，然后运行则是把编译声称的.class文件交给Java虚拟机(JVM)执行。而我们所说的类加载过程即是指JVM虚拟机把.class文件中类信息加载进内存，并进行解析生成对应的class对象的过程。 简单来说:加载指的是把class字节码文件从各个来源通过类加载器装载入内存中。 举个通俗点的????： JVM
深入理解Java虚拟机：揭秘JVM的奥秘与力量 !
2301_79339087的博客
04-21 1335
在编程世界中，Java以其“一次编写，到处运行”的特性赢得了广大开发者们的青睐。这背后的功臣，便是Java虚拟机（Java Virtual Machine，简称JVM）。JVM作为Java语言的运行环境，不仅实现了跨平台的特性，更通过其强大的内存管理和垃圾回收机制(GC 机制)、字节码执行、动态类加载等核心功能，赋予了Java程序高效、稳定和灵活的运行特性。本文将带领您深入理解Java虚拟机，揭示其背后的奥秘与力量。
java虚拟机源码学习-deep-learning-to-jvm:深入理解Java虚拟机源码学习
05-20
类加载过程包括加载、验证、准备、解析和初始化。双亲委派模型是JVM默认的类加载机制，它保证了类加载的唯一性，防止类被重复加载。 6. **源码学习价值** 分析JVM源码有助于理解Java程序的运行过程，如内存分配、...
深入理解Java虚拟机（jvm性能调优+内存模型+虚拟机原理）.zip
09-27
类加载机制负责从磁盘加载类文件到JVM，包括加载、链接和初始化三个步骤。字节码执行引擎则是JVM的心脏，它通过解释器或即时编译器（JIT）将字节码转换为机器码。JIT技术能够在运行时动态优化代码，显著提升性能。...
java虚拟机源码-DeepInJVM:深入理解Java虚拟机第二版
05-21
《DeepInJVM:深入理解Java虚拟机第二版》是一本深入探讨Java虚拟机（JVM）工作原理和技术细节的专业书籍。在这个压缩包文件中，包含的资源是该书的源码，对于学习和理解JVM有着极大的帮助。"系统开源"的标签表明这些...
大厂笔试现已经禁用本地IDE怎么看
HONEY MOOSE
10-04 1988
如果我说本来面试做题这种事情就是反人类你相信吗？这个罪恶的源头就是 Google，说是为了选择高素质的计算机编程水平的人才，然后把面试就变成了考试，最大的受益者当然是印度人了。当把一个考察过程变成标准化的考试过程，那么整个过程自然就有作弊的，因为只要有考试就会有舞弊这个几千年都没改过。所以三哥在面试这个事情上一直乐此不疲，结果把很多优秀的其他国家的程序员统统刷了出去，抬高了壁垒，同时养活一批刷题网站和美国移民局，来申请工作签证嘛。
面试中考察栈和队列的经典算法题
A Charmer 的博客
09-30 1392
通过以上对栈和队列面试常见题目的分析与解答，希望能帮助你更好地理解和掌握这两种数据结构在面试中的应用，提高你在数据结构方面的解题能力和应对面试的信心。在实际准备面试过程中，建议你多做练习，深入理解每种数据结构的特点和操作方法，以便能够灵活运用它们解决各种问题。如果你还有其他问题或需要进一步的解释，欢迎随时提问。
2024Java最新面试题总结（针对于一些小厂、中厂）
最新发布
weixin_62375676的博客
10-07 677
2024最新Java面试题，针对一些小厂，中厂
前端算法合集-1（含面试题）
m0_63324578的博客
09-30 427
给定一个包含重复元素的数组，请你编写一个函数对数组进行去重，并按元素出现的次数从高到低排序。如果次数相同，则按元素值从小到大排序。(这是我面试一家中厂公司的二面算法题)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值