备案控制台
开发者社区 开发与运维 文章 正文

面经手册 · 第24篇《为了搞清楚类加载，竟然手撸JVM！》

2022-01-13 148
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 写个代码加载下1. 案例工程2. 代码讲解五、解析字节码文件1. 提取部分字节码2. 解析魔数并校验3. 解析版本号信息4. 解析全部内容对照

目录


  • 一、前言
  • 二、面试题
  • 三、类加载过程描述
  • 四、写个代码加载下
  • 1. 案例工程
  • 2. 代码讲解
  • 五、解析字节码文件
  • 1. 提取部分字节码
  • 2. 解析魔数并校验
  • 3. 解析版本号信息
  • 4. 解析全部内容对照
  • 六、总结
  • 七、系列推荐


一、前言

学习，不知道从哪下手？

当学习一个新知识不知道从哪下手的时候，最有效的办法是梳理这个知识结构的脉络信息，汇总出一整张的思维导出。接下来就是按照思维导图的知识结构，一个个学习相应的知识点，并汇总记录。

就像JVM的学习，可以说它包括了非常多的内容，也是一个庞大的知识体系。例如：类加载、加载器、生命周期、性能优化、调优参数、调优工具、优化方案、内存区域、虚拟机栈、直接内存、内存溢出、元空间、垃圾回收、可达性分析、标记清除、回收过程等等。如果没有梳理的一头扎进去，东一榔头西一棒子，很容易造成学习恐惧感。

如图 24-1 是 JVM 知识框架梳理，后续我们会按照这个结构陆续讲解每一块内容。

0.jpg图 24-1 JVM 知识框架

二、面试题

谢飞机，小记！，很多知识根本就是背背背，也没法操作，难学！

「谢飞机」：大哥，你问我两个JVM问题，我看看我自己还行不！

「面试官」：啊？嗯！往死了问还是？

「谢飞机」：就就就，都行！你看着来！

「面试官」：啊，那 JVM 加载过程都是什么步骤？

「谢飞机」：巴拉巴拉，加载、验证、准备、解析、初始化、使用、卸载！

「面试官」：嗯，背的挺好！我怀疑你没操作过！ 那加载的时候，JVM 规范规定从第几位开始是解析常量池，以及数据类型是如何定义的，u1、u2、u4，是怎么个玩意？

「谢飞机」：握草！算了，告诉我看啥吧！

三、类加载过程描述

1.jpgimage.gif图 24-2 JVM 类加载过程

「JVM 类加载过程分为」，加载、链接、初始化、使用和卸载这四个阶段，在链接中又包括：验证、准备、解析。

  • 「加载」：Java 虚拟机规范对 class 文件格式进行了严格的规则，但对于从哪里加载 class 文件，却非常自由。Java 虚拟机实现可以从文件系统读取、从JAR(或ZIP)压缩包中提取 class 文件。除此之外也可以通过网络下载、数据库加载，甚至是运行时直接生成的 class 文件。
  • 「链接」：包括了三个阶段；
  • 验证，确保被加载类的正确性，验证字节流是否符合 class 文件规范，例魔数 0xCAFEBABE，以及版本号等。
  • 准备，为类的静态变量分配内存并设置变量初始值等
  • 解析，解析包括解析出常量池数据和属性表信息，这里会包括 ConstantPool 结构体以及 AttributeInfo 接口等。
  • 「初始化」：类加载完成的最后一步就是初始化，目的就是为标记常量值的字段赋值，以及执行 <clinit> 方法的过程。JVM虚拟机通过锁的方式确保 clinit 仅被执行一次
  • 「使用」：程序代码执行使用阶段。
  • 「卸载」：程序代码退出、异常、结束等。

四、写个代码加载下

JVM 之所以不好掌握，主要是因为不好实操。虚拟机是 C++ 写的，很多 Java 程序员根本就不会去读，或者读不懂。那么，也就没办法实实在在的体会到，到底是怎么加载的，加载的时候都干了啥。只有看到代码，我才觉得自己学会了！

所以，我们这里要手动写一下，JVM 虚拟机的部分代码，也就是类加载的过程。通过 Java 代码来实现 Java 虚拟机的部分功能，让开发 Java 代码的程序员更容易理解虚拟机的执行过程。

1. 案例工程

interview-24
├── pom.xml
└── src
    └── main
    │    └── java
    │        └── org.itstack.interview.jvm
    │             ├── classpath
    │             │   ├── impl
    │             │   │   ├── CompositeEntry.java
    │             │   │   ├── DirEntry.java 
    │             │   │   ├── WildcardEntry.java 
    │             │   │   └── ZipEntry.java    
    │             │   ├── Classpath.java
    │             │   └── Entry.java    
    │             ├── Cmd.java
    │             └── Main.java
    └── test
         └── java
             └── org.itstack.interview.jvm.test
                 └── HelloWorld.java

「以上」，工程结构就是按照 JVM 虚拟机规范，使用 Java 代码实现 JVM 中加载 class 文件部分内容。当然这部分还不包括解析，因为解析部分的代码非常庞大，我们先从把 .class 文件加载读取开始了解。

2. 代码讲解

2.1 定义类路径接口(Entry)

public interface Entry {
    byte[] readClass(String className) throws IOException;
    static Entry create(String path) {
        //File.pathSeparator；路径分隔符(win\linux)
        if (path.contains(File.pathSeparator)) {
            return new CompositeEntry(path);
        }
        if (path.endsWith("*")) {
            return new WildcardEntry(path);
        }
        if (path.endsWith(".jar") || path.endsWith(".JAR") ||
                path.endsWith(".zip") || path.endsWith(".ZIP")) {
            return new ZipEntry(path);
        }
        return new DirEntry(path);
    }
}
  • 接口中提供了接口方法 readClass 和静态方法 create(String path)。
  • jdk1.8 是可以在接口中编写静态方法的，在设计上属于补全了抽象类的类似功能。这个静态方法主要是按照不同的路径地址类型，提供不同的解析方法。包括：CompositeEntry、WildcardEntry、ZipEntry、DirEntry，这四种。接下来分别看每一种的具体实现

2.2 目录形式路径(DirEntry)

public class DirEntry implements Entry {
    private Path absolutePath;
    public DirEntry(String path){
        //获取绝对路径
        this.absolutePath = Paths.get(path).toAbsolutePath();
    }
    @Override
    public byte[] readClass(String className) throws IOException {
        return Files.readAllBytes(absolutePath.resolve(className));
    }
    @Override
    public String toString() {
        return this.absolutePath.toString();
    }
}
  • 目录形式的通过读取绝对路径下的文件，通过 Files.readAllBytes 方式获取字节码。

2.3 压缩包形式路径(ZipEntry)

public class ZipEntry implements Entry {
    private Path absolutePath;
    public ZipEntry(String path) {
        //获取绝对路径
        this.absolutePath = Paths.get(path).toAbsolutePath();
    }
    @Override
    public byte[] readClass(String className) throws IOException {
        try (FileSystem zipFs = FileSystems.newFileSystem(absolutePath, null)) {
            return Files.readAllBytes(zipFs.getPath(className));
        }
    }
    @Override
    public String toString() {
        return this.absolutePath.toString();
    }
}
  • 其实压缩包形式与目录形式，只有在文件读取上有包装差别而已。FileSystems.newFileSystem

2.4 混合形式路径(CompositeEntry)

public class CompositeEntry implements Entry {
    private final List<Entry> entryList = new ArrayList<>();
    public CompositeEntry(String pathList) {
        String[] paths = pathList.split(File.pathSeparator);
        for (String path : paths) {
            entryList.add(Entry.create(path));
        }
    }
    @Override
    public byte[] readClass(String className) throws IOException {
        for (Entry entry : entryList) {
            try {
                return entry.readClass(className);
            } catch (Exception ignored) {
                //ignored
            }
        }
        throw new IOException("class not found " + className);
    }
    @Override
    public String toString() {
        String[] strs = new String[entryList.size()];
        for (int i = 0; i < entryList.size(); i++) {
            strs[i] = entryList.get(i).toString();
        }
        return String.join(File.pathSeparator, strs);
    }
}
  • File.pathSeparator，是一个分隔符属性，win/linux 有不同的类型，所以使用这个方法进行分割路径。
  • 分割后的路径装到 List 集合中，这个过程属于拆分路径。

2.5 通配符类型路径(WildcardEntry)

public class WildcardEntry extends CompositeEntry {
    public WildcardEntry(String path) {
        super(toPathList(path));
    }
    private static String toPathList(String wildcardPath) {
        String baseDir = wildcardPath.replace("*", ""); // remove *
        try {
            return Files.walk(Paths.get(baseDir))
                    .filter(Files::isRegularFile)
                    .map(Path::toString)
                    .filter(p -> p.endsWith(".jar") || p.endsWith(".JAR"))
                    .collect(Collectors.joining(File.pathSeparator));
        } catch (IOException e) {
            return "";
        }
    }
}
  • 这个类属于混合形式路径处理类的子类，唯一提供的方法就是把类路径解析出来。

2.6 类路径解析(Classpath)

启动类路径、扩展类路径、用户类路径，熟悉吗？是不经常看到这几句话，那么时候怎么实现的呢？

有了上面我们做的一些基础类的工作，接下来就是类解析的实际调用过程。代码如下：

public class Classpath {
    private Entry bootstrapClasspath;  //启动类路径
    private Entry extensionClasspath;  //扩展类路径
    private Entry userClasspath;       //用户类路径
    public Classpath(String jreOption, String cpOption) {
        //启动类&扩展类 "C:\Program Files\Java\jdk1.8.0_161\jre"
        bootstrapAndExtensionClasspath(jreOption);
        //用户类 F:\..\org\itstack\demo\test\HelloWorld
        parseUserClasspath(cpOption);
    }
    private void bootstrapAndExtensionClasspath(String jreOption) {
        String jreDir = getJreDir(jreOption);
        //..jre/lib/*
        String jreLibPath = Paths.get(jreDir, "lib") + File.separator + "*";
        bootstrapClasspath = new WildcardEntry(jreLibPath);
        //..jre/lib/ext/*
        String jreExtPath = Paths.get(jreDir, "lib", "ext") + File.separator + "*";
        extensionClasspath = new WildcardEntry(jreExtPath);
    }
    private static String getJreDir(String jreOption) {
        if (jreOption != null && Files.exists(Paths.get(jreOption))) {
            return jreOption;
        }
        if (Files.exists(Paths.get("./jre"))) {
            return "./jre";
        }
        String jh = System.getenv("JAVA_HOME");
        if (jh != null) {
            return Paths.get(jh, "jre").toString();
        }
        throw new RuntimeException("Can not find JRE folder!");
    }
    private void parseUserClasspath(String cpOption) {
        if (cpOption == null) {
            cpOption = ".";
        }
        userClasspath = Entry.create(cpOption);
    }
    public byte[] readClass(String className) throws Exception {
        className = className + ".class";
        //[readClass]启动类路径
        try {
            return bootstrapClasspath.readClass(className);
        } catch (Exception ignored) {
            //ignored
        }
        //[readClass]扩展类路径
        try {
            return extensionClasspath.readClass(className);
        } catch (Exception ignored) {
            //ignored
        }
        //[readClass]用户类路径
        return userClasspath.readClass(className);
    }
}
  • 启动类路径，bootstrapClasspath.readClass(className);
  • 扩展类路径，extensionClasspath.readClass(className);
  • 用户类路径，userClasspath.readClass(className);
  • 这回就看到它们具体在哪使用了吧！有了具体的代码也就方便理解了

2.7 加载类测试验证

private static void startJVM(Cmd cmd) {
    Classpath cp = new Classpath(cmd.jre, cmd.classpath);
    System.out.printf("classpath：%s class：%s args：%s\n", cp, cmd.getMainClass(), cmd.getAppArgs());
    //获取className
    String className = cmd.getMainClass().replace(".", "/");
    try {
        byte[] classData = cp.readClass(className);
        System.out.println(Arrays.toString(classData));
    } catch (Exception e) {
        System.out.println("Could not find or load main class " + cmd.getMainClass());
        e.printStackTrace();
    }
}

这段就是使用 Classpath 类进行类路径加载，这里我们测试加载 java.lang.String 类。你可以加载其他的类，或者自己写的类

  • 配置IDEA，program arguments 参数：-Xjre "C:\Program Files\Java\jdk1.8.0_161\jre" java.lang.String
  • 另外这里读取出的 class 文件信息，打印的是 byte 类型信息。

「测试结果」

[-54, -2, -70, -66, 0, 0, 0, 52, 2, 28, 3, 0, 0, -40, 0, 3, 0, 0, -37, -1, 3, 0, 0, -33, -1, 3, 0, 1, 0, 0, 8, 0, 15, 8, 0, 61, 8, 0, 85, 8, 0, 88, 8, 0, 89, 8, 0, 112, 8, 0, -81, 8, 0, -75, 8, 0, -47, 8, 0, -45, 1, 0, 0, 1, 0, 3, 40, 41, 73, 1, 0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 59, 1, 0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 3, 40, 41, 86, 1, 0, 3, 40, 41, 90, 1, 0, 4, 40, 41, 91, ...]

这块部分截取的程序运行打印结果，就是读取的 class 文件信息，只不过暂时还不能看出什么。接下来我们再把它翻译过来！

五、解析字节码文件

JVM 在把 class 文件加载完成后，接下来就进入链接的过程，这个过程包括了内容的校验、准备和解析，其实就是把 byte 类型 class 翻译过来，做相应的操作。

整个这个过程内容相对较多，这里只做部分逻辑的实现和讲解。如果读者感兴趣可以阅读小傅哥的《用Java实现JVM》专栏。

1. 提取部分字节码

//取部分字节码：java.lang.String
private static byte[] classData = {
        -54, -2, -70, -66, 0, 0, 0, 52, 2, 26, 3, 0, 0, -40, 0, 3, 0, 0, -37, -1, 3, 0, 0, -33, -1, 3, 0, 1, 0, 0, 8, 0,
        59, 8, 0, 83, 8, 0, 86, 8, 0, 87, 8, 0, 110, 8, 0, -83, 8, 0, -77, 8, 0, -49, 8, 0, -47, 1, 0, 3, 40, 41, 73, 1,
        0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 59, 1, 0, 20, 40, 41,
        76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 3, 40, 41, 86, 1, 0, 3,
        40, 41, 90, 1, 0, 4, 40, 41, 91, 66, 1, 0, 4, 40, 41, 91, 67, 1, 0, 4, 40, 67, 41, 67, 1, 0, 21, 40, 68, 41, 76,
        106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 4, 40, 73, 41, 67, 1, 0, 4};
  • java.lang.String 解析出来的字节码内容较多，当然包括的内容也多，比如魔数、版本、类、常量、方法等等。所以我们这里只截取部分进行进行解析。

2. 解析魔数并校验

很多文件格式都会规定满足该格式的文件必须以某几个固定字节开头，这几个字节主要起到标识作用，叫作魔数(magic number)。

例如；

  • PDF文件以4字节“%PDF”(0x25、0x50、0x44、0x46)开头，
  • ZIP文件以2字节“PK”(0x50、0x4B)开头
  • class文件以4字节“0xCAFEBABE”开头
private static void readAndCheckMagic() {
    System.out.println("\r\n------------ 校验魔数 ------------");
    //从class字节码中读取前四位
    byte[] magic_byte = new byte[4];
    System.arraycopy(classData, 0, magic_byte, 0, 4);
    //将4位byte字节转成16进制字符串
    String magic_hex_str = new BigInteger(1, magic_byte).toString(16);
    System.out.println("magic_hex_str：" + magic_hex_str);
    //byte_magic_str 是16进制的字符串，cafebabe，因为java中没有无符号整型，所以如果想要无符号只能放到更高位中
    long magic_unsigned_int32 = Long.parseLong(magic_hex_str, 16);
    System.out.println("magic_unsigned_int32：" + magic_unsigned_int32);
    //魔数比对，一种通过字符串比对，另外一种使用假设的无符号16进制比较。如果使用无符号比较需要将0xCAFEBABE & 0x0FFFFFFFFL与运算
    System.out.println("0xCAFEBABE & 0x0FFFFFFFFL：" + (0xCAFEBABE & 0x0FFFFFFFFL));
    if (magic_unsigned_int32 == (0xCAFEBABE & 0x0FFFFFFFFL)) {
        System.out.println("class字节码魔数无符号16进制数值一致校验通过");
    } else {
        System.out.println("class字节码魔数无符号16进制数值一致校验拒绝");
    }
}
  • 读取字节码中的前四位，-54, -2, -70, -66，将这四位转换为16进制。
  • 因为 java 中是没有无符号整型的，所以只能用更高位存放。
  • 解析后就是魔数的对比，看是否与 CAFEBABE 一致。

「测试结果」

------------ 校验魔数 ------------
magic_hex_str：cafebabe
magic_unsigned_int32：3405691582
0xCAFEBABE & 0x0FFFFFFFFL：3405691582
class字节码魔数无符号16进制数值一致校验通过

3. 解析版本号信息

刚才我们已经读取了4位魔数信息，接下来再读取2位，是版本信息。

魔数之后是class文件的次版本号和主版本号，都是u2类型。假设某class文件的主版本号是M，次版本号是m，那么完整的版本号可以表示成“M.m”的形式。次版本号只在J2SE 1.2之前用过，从1.2开始基本上就没有什么用了(都是0)。主版本号在J2SE 1.2之前是45，从1.2开始，每次有大版本的Java版本发布，都会加1｛45、46、47、48、49、50、51、52｝

private static void readAndCheckVersion() {
    System.out.println("\r\n------------ 校验版本号 ------------");
    //从class字节码第4位开始读取，读取2位
    byte[] minor_byte = new byte[2];
    System.arraycopy(classData, 4, minor_byte, 0, 2);
    //将2位byte字节转成16进制字符串
    String minor_hex_str = new BigInteger(1, minor_byte).toString(16);
    System.out.println("minor_hex_str：" + minor_hex_str);
    //minor_unsigned_int32 转成无符号16进制
    int minor_unsigned_int32 = Integer.parseInt(minor_hex_str, 16);
    System.out.println("minor_unsigned_int32：" + minor_unsigned_int32);
    //从class字节码第6位开始读取，读取2位
    byte[] major_byte = new byte[2];
    System.arraycopy(classData, 6, major_byte, 0, 2);
    //将2位byte字节转成16进制字符串
    String major_hex_str = new BigInteger(1, major_byte).toString(16);
    System.out.println("major_hex_str：" + major_hex_str);
    //major_unsigned_int32 转成无符号16进制
    int major_unsigned_int32 = Integer.parseInt(major_hex_str, 16);
    System.out.println("major_unsigned_int32：" + major_unsigned_int32);
    System.out.println("版本号：" + major_unsigned_int32 + "." + minor_unsigned_int32);
}
  • 这里有一个小技巧，class 文件解析出来是一整片的内容，JVM 需要按照虚拟机规范，一段一段的解析出所有的信息。
  • 同样这里我们需要把2位byte转换为16进制信息，并继续从第6位继续读取2位信息。组合出来的才是版本信息。

「测试结果」

------------ 校验版本号 ------------
minor_hex_str：0
minor_unsigned_int32：0
major_hex_str：34
major_unsigned_int32：52
版本号：52.0

4. 解析全部内容对照

按照 JVM 的加载过程，其实远不止魔数和版本号信息，还有很多其他内容，这里我们可以把测试结果展示出来，方便大家有一个学习结果的比对印象。

classpath：org.itstack.demo.jvm.classpath.Classpath@4bf558aa class：java.lang.String args：null
version: 52.0
constants count：540
access flags：0x31
this class：java/lang/String
super class：java/lang/Object
interfaces：[java/io/Serializable, java/lang/Comparable, java/lang/CharSequence]
fields count：5
value    [C
hash    I
serialVersionUID    J
serialPersistentFields    [Ljava/io/ObjectStreamField;
CASE_INSENSITIVE_ORDER    Ljava/util/Comparator;
methods count: 94
<init>    ()V
<init>    (Ljava/lang/String;)V
<init>    ([C)V
<init>    ([CII)V
<init>    ([III)V
<init>    ([BIII)V
<init>    ([BI)V
checkBounds    ([BII)V
<init>    ([BIILjava/lang/String;)V
<init>    ([BIILjava/nio/charset/Charset;)V
<init>    ([BLjava/lang/String;)V
<init>    ([BLjava/nio/charset/Charset;)V
<init>    ([BII)V
<init>    ([B)V
<init>    (Ljava/lang/StringBuffer;)V
<init>    (Ljava/lang/StringBuilder;)V
<init>    ([CZ)V
length    ()I
isEmpty    ()Z
charAt    (I)C
codePointAt    (I)I
codePointBefore    (I)I
codePointCount    (II)I
offsetByCodePoints    (II)I
getChars    ([CI)V
getChars    (II[CI)V
getBytes    (II[BI)V
getBytes    (Ljava/lang/String;)[B
getBytes    (Ljava/nio/charset/Charset;)[B
getBytes    ()[B
equals    (Ljava/lang/Object;)Z
contentEquals    (Ljava/lang/StringBuffer;)Z
nonSyncContentEquals    (Ljava/lang/AbstractStringBuilder;)Z
contentEquals    (Ljava/lang/CharSequence;)Z
equalsIgnoreCase    (Ljava/lang/String;)Z
compareTo    (Ljava/lang/String;)I
compareToIgnoreCase    (Ljava/lang/String;)I
regionMatches    (ILjava/lang/String;II)Z
regionMatches    (ZILjava/lang/String;II)Z
startsWith    (Ljava/lang/String;I)Z
startsWith    (Ljava/lang/String;)Z
endsWith    (Ljava/lang/String;)Z
hashCode    ()I
indexOf    (I)I
indexOf    (II)I
indexOfSupplementary    (II)I
lastIndexOf    (I)I
lastIndexOf    (II)I
lastIndexOfSupplementary    (II)I
indexOf    (Ljava/lang/String;)I
indexOf    (Ljava/lang/String;I)I
indexOf    ([CIILjava/lang/String;I)I
indexOf    ([CII[CIII)I
lastIndexOf    (Ljava/lang/String;)I
lastIndexOf    (Ljava/lang/String;I)I
lastIndexOf    ([CIILjava/lang/String;I)I
lastIndexOf    ([CII[CIII)I
substring    (I)Ljava/lang/String;
substring    (II)Ljava/lang/String;
subSequence    (II)Ljava/lang/CharSequence;
concat    (Ljava/lang/String;)Ljava/lang/String;
replace    (CC)Ljava/lang/String;
matches    (Ljava/lang/String;)Z
contains    (Ljava/lang/CharSequence;)Z
replaceFirst    (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
replaceAll    (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
replace    (Ljava/lang/CharSequence;Ljava/lang/CharSequence;)Ljava/lang/String;
split    (Ljava/lang/String;I)[Ljava/lang/String;
split    (Ljava/lang/String;)[Ljava/lang/String;
join    (Ljava/lang/CharSequence;[Ljava/lang/CharSequence;)Ljava/lang/String;
join    (Ljava/lang/CharSequence;Ljava/lang/Iterable;)Ljava/lang/String;
toLowerCase    (Ljava/util/Locale;)Ljava/lang/String;
toLowerCase    ()Ljava/lang/String;
toUpperCase    (Ljava/util/Locale;)Ljava/lang/String;
toUpperCase    ()Ljava/lang/String;
trim    ()Ljava/lang/String;
toString    ()Ljava/lang/String;
toCharArray    ()[C
format    (Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
format    (Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
valueOf    (Ljava/lang/Object;)Ljava/lang/String;
valueOf    ([C)Ljava/lang/String;
valueOf    ([CII)Ljava/lang/String;
copyValueOf    ([CII)Ljava/lang/String;
copyValueOf    ([C)Ljava/lang/String;
valueOf    (Z)Ljava/lang/String;
valueOf    (C)Ljava/lang/String;
valueOf    (I)Ljava/lang/String;
valueOf    (J)Ljava/lang/String;
valueOf    (F)Ljava/lang/String;
valueOf    (D)Ljava/lang/String;
intern    ()Ljava/lang/String;
compareTo    (Ljava/lang/Object;)I
<clinit>    ()V
Process finished with exit code 0

六、总结

  • 学习 JVM 最大的问题是不好实践，所以本文以案例实操的方式，学习 JVM 的加载解析过程。也让更多的对 JVM 感兴趣的研发，能更好的接触到 JVM 并深入的学习。
  • 有了以上这段代码，大家可以参照 JVM 虚拟机规范，在调试Java版本的JVM，这样就可以非常容易理解整个JVM的加载过程，都做了什么。
  • 如果大家需要文章中一些原图 xmind 或者源码，可以添加作者小傅哥(fustack)，或者关注公众号：bugstack虫洞栈进行获取。好了，本章节就扯到这，后续还有很多努力，持续原创，感谢大家的支持！

七、系列推荐

文章标签：
云虚拟主机
云解析DNS
Java
C++
Linux
程序员
数据库
关键词：
JVM手册
小傅哥
目录
相关文章
1932836719192345
|
3月前
|
存储 Java 调度
JVM指令手册
JVM指令手册汇总
1932836719192345
28 2
极客李华
|
4月前
|
存储 监控 算法
JVM入门手册（通俗版）
JVM入门手册（通俗版）
极客李华
32 0
愿天堂没有BUG（公众号同名）
|
6月前
|
运维 监控 算法
连续仨月霸占牛客榜首！京东T8呕心巨作：700页JVM虚拟机实战手册
虚拟机是一种抽象化的计算机，通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机有自己完善的硬体架构，如处理器、堆栈、寄存器等，还具有相应的指令系统。JVM屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。
愿天堂没有BUG（公众号同名）
29 0
myysophia
|
10月前
|
存储 Java 调度
00-JVM指令手册
00-JVM指令手册
myysophia
30 0
柯南二号
|
11月前
|
Java
JVM指令手册
JVM指令手册
柯南二号
115 0
游客tmj4hgt7bfvas
|
负载均衡 算法 Java
终于把JVM垃圾回收的来龙去脉搞清楚了（下）
终于把JVM垃圾回收的来龙去脉搞清楚了（下）
游客tmj4hgt7bfvas
136 0
游客tmj4hgt7bfvas
|
存储 缓存 算法
终于把JVM垃圾回收的来龙去脉搞清楚了（上）
终于把JVM垃圾回收的来龙去脉搞清楚了（上）
游客tmj4hgt7bfvas
129 0
p2jbaco26vdds
|
存储 Java 调度
附录--JVM指令手册
附录--JVM指令手册
p2jbaco26vdds
174 0
上分如喝水
|
自然语言处理 Oracle Java
拜托搞清楚，JVM是程序员必'备'，不是必'背'，每天20分钟带你从入门到揭秘JVM
大部分Java开发人员，除会在项目中使用到与Java平台相关的各种高精尖技术，对于Java技术的核心Java虚拟机了解甚少，一些有一定工作经验的开发人员，打心眼儿里觉得SSM、微服务等上层技术才是重点，基础技术并不重要，这其实是一种本末倒置的“病态”。如果我们把核心类库的API比做数学公式的话，那么Java虚拟机的知识就好比公式的推导过程。
上分如喝水
223 0
拜托搞清楚，JVM是程序员必'备'，不是必'背'，每天20分钟带你从入门到揭秘JVM
小傅哥
|
监控 算法 安全
面经手册 · 第27篇《JVM 判断对象已死，实践验证GC回收》
先动手验证垃圾回收 JVM 垃圾回收知识框架 1. 判断对象已死 2. 垃圾回收算法 3. 垃圾回收器
小傅哥
199 0
面经手册 · 第27篇《JVM 判断对象已死，实践验证GC回收》

热门文章

最新文章

  • 1
    JVM Profiler IOProfiler
  • 2
    JVM加载对象时内存加载顺序
  • 3
    全面认识Eclipse中JVM内存设置(转)
  • 4
    《深入解析Android 虚拟机》——第2章，第2.2节Java虚拟机概述
  • 5
    jvm优化
  • 6
    感觉JVM的默认异常处理不够好，既然不好那我们就自己来处理异常呗！那么如何自己处理异常呢？
  • 7
    深入理解JVM(七)——Class文件结构
  • 8
    JVM 语言的兴衰 【The Rise and Fall of JVM Languages】
  • 9
    Java内存管理 -JVM 垃圾回收
  • 10
    JVM垃圾回收（GC）整理总结学习
  • 1
    深入剖析JVM内存管理与对象创建原理
    46
  • 2
    JDK、JRE 和 JVM 的区别和联系
    24
  • 3
    深入理解Java虚拟机：类加载机制
    15
  • 4
    【JVM】深入理解JVM对象内存分配方式
    31
  • 5
    【JVM】了解JVM中动态判断对象年龄的原理
    27
  • 6
    【JVM】分代收集算法：提升Java垃圾回收效率
    24
  • 7
    【JVM】深入了解JVM方法区
    21
  • 8
    【JVM】深入理解Java引用类型：强引用、软引用、弱引用和虚引用
    141
  • 9
    【JVM】Java堆 ：深入理解内存中的对象世界
    60
  • 10
    【JVM】Java虚拟机栈（Java Virtual Machine Stacks）
    39

    • 相关课程

    更多
  • Java面试疑难点解析 - 系统架构及项目设计
  • Go语言完全自学手册图文教程
  • 「大师课」搞定 Java 开发基础
  • Java面试疑难点解析 - 面试技巧及语言基础
  • 程序设计类比赛汇总

    • 相关电子书

    更多
  • JVM实战
  • JVM的GC
  • 基于JVM的脚本语言开发、运用实践

    • 相关实验场景

    更多
  • 代码质量提升小妙招
  • 1分钟部署经典小游戏
  • 搭建超级小班课网课系统
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）