JVM-JVM如何加载类

一、Java 语言的类型可以分为两大类：

• 基本类型（primitive types）
• 引用类型（reference types）：类、接口、数组类和泛型参数（泛型参数会在编译中被擦除），因此Java虚拟机里的引用类型实际上只有前三种
  • 数组类：是由 Java 虚拟机直接生成的（Java中数组的特性）
  • 类、接口：有对应的字节流，都会被加载到Java虚拟机中，成为类或接口
  • 最常见：Java编译器生成的class文件
  • 其他：也可以在程序内部直接生成，或者从网络中获取（例如网页中内嵌的小程序 Java applet）字节流

二、Java虚拟机是如何加载类的

1、加载： 

• 定义：加载，是指查找字节流，并且据此创建类的过程。前面提到，对于数组类来说，它并没有对应的字节流，而是由 Java 虚拟机直接生成的。对于其他的类来说，Java 虚拟机则需要借助类加载器来完成查找字节流的过程
• 双亲委派模型：村里的建筑师有一个潜规则，就是接到单子自己不能着手干，得先给师傅过过目。师傅不接手的情况下，才能自己来。在 Java 虚拟机中，这个潜规则有个特别的名字，叫双亲委派模型。每当一个类加载器接收到加载请求时，它会先将请求转发给父类加载器。在父类加载器没有找到所请求的类的情况下，该类加载器才会尝试去加载。
  • 爷：共同的祖师爷（启动类加载器 BootstrapClassLoader）：加载最基础、最重要的类，启动类加载器是由 C++ 实现的，没有对应的 Java 类，因此在 Java 中只能用 null 来指代。
  • 父：扩展类加载器（sun.misc.Launcher$ExtClassLoader）：它负责加载相对次要、但又通用的类，比如存放在 JRE 的 lib/ext 目录下 jar 包中的类（以及由系统变量 java.ext.dirs 指定的类）
    • Java 9 扩展类加载器被改名为平台类加载器（platform class loader）
  • 子：应用类加载器（sun.misc.Launcher$AppClassLoader）：它负责加载应用程序路径下的类。（这里的应用程序路径，便是指虚拟机参数 -cp/-classpath、系统变量 java.class.path 或环境变量 CLASSPATH 所指定的路径。）默认情况下，应用程序中包含的类便是由应用类加载器加载的。
  • 自定义：还可以自定义类加载器，来实现特殊的加载方式。举例来说，我们可以对 class 文件进行加密，加载时再利用自定义的类加载器对其解密。
• 类加载器还有命名空间的作用，在 Java 虚拟机中，类的唯一性是由类加载器实例以及类的全名一同确定的

例子：

package javap.loader;

import sun.misc.Launcher;

public class LoaderTest {
    public static void main(String[] args) {

        /**
         * sun.misc.Launcher类是java的入口，在启动java应用的时候会首先创建Launcher类，
         * 创建Launcher类的时候会准备应用程序运行中需要的类加载器。
         * Laucher是由JVM创建的，它类加载器应该是BootStrapClassLoader， 这是一个C++编写的类加载器，所以打印null
         */
        System.out.println("Launcher.classLoader=" + Launcher.class.getClassLoader());  // null

        // 获取AppClassLoader
        System.out.println("SystemClassLoader=" + ClassLoader.getSystemClassLoader()); // sun.misc.Launcher$AppClassLoader@135fbaa4

        // 获取父加载器
        ClassLoader classLoader = LoaderTest.class.getClassLoader();
        System.out.println("this.classLoader=" + classLoader);  // sun.misc.Launcher$AppClassLoader@135fbaa4
        System.out.println("this.classLoader.father=" + classLoader.getParent()); // sun.misc.Launcher$ExtClassLoader@2503dbd3
        System.out.println("this.classLoader.father.father=" + classLoader.getParent().getParent());  // null
        System.out.println("this.classLoader.father.father.father=" + classLoader.getParent().getParent().getParent()); // NullPointerException exception
    }
}

结果：

Launcher.classLoader=null
SystemClassLoader=sun.misc.Launcher$AppClassLoader@135fbaa4
this.classLoader=sun.misc.Launcher$AppClassLoader@135fbaa4
this.classLoader.father=sun.misc.Launcher$ExtClassLoader@2503dbd3
this.classLoader.father.father=null
Exception in thread "main" java.lang.NullPointerException
    at javap.loader.LoaderTest.main(LoaderTest.java:21)

Process finished with exit code 1

双亲委派模型说明：（查看）

　　

　　双亲委派模型最大的好处就是让Java类同其类加载器一起具备了一种带优先级的层次关系。举个例子来说明下：比如我们要加载顶层的Java类——java.lang.Object类，无论我们用哪个类加载器去加载Object类，这个加载请求最终都会委托给启动类加载器（Bootstrap ClassLoader），这样就保证了所有加载器加载的Object类都是同一个类。如果没有双亲委派模型，就会出现 Wupx::Object 和 Huyx::Object 这样两个不同的Object类。

　　“ClassLoader+类的全路径” 可唯一确定一个类对象，如果相同的字节码文件被不同的ClassLoader加载，将在内存中生成两个不同的对象，这样在引用、赋值、类型转换等情况下都会存在问题。jvm使用双亲委派模型来尽最大程度保证相同的class被相同的加载器所加载。

 例：

public class test {

    public static void main(String[] args) throws Throwable{
        Class myClazz = loadClass(new String[] { "file:/Users/**/Documents/dc-x/test/target/classes/" }, null, "com.MyClassLoader");
        System.out.println(myClazz.getClassLoader());

        Class appClazz1 = Class.forName("com.MyClassLoader");

        System.out.println(myClazz.equals(appClazz1));

        Class appClazz2 = Class.forName("com.MyClassLoader");

        System.out.println(appClazz1.equals(appClazz2));
        MyClassLoader myClassLoader = (MyClassLoader)myClazz.newInstance(); // 这说明，相同路径下的.class文件，被不同类加载器加载到内存中会生成两个不同的对象；进行类型转换时发生ClassCastException
    }

    public static Class<?> loadClass(String[] pathArray, ClassLoader parentClassLoader, String className) throws Throwable {
        List<URL> list = new ArrayList<>();
        for (String path : pathArray) {
            URL url = new URL(path);
            list.add(url);
        }

        URL[] urls = list.toArray(new URL[list.size()]);
        URLClassLoader classLoader = new URLClassLoader(urls, parentClassLoader);

        Class<?> clazz = classLoader.loadClass(className);

        return clazz;
    }
}

结果：

java.net.URLClassLoader@1d44bcfa
false
true
Exception in thread "main" java.lang.ClassCastException: com.MyClassLoader cannot be cast to com.MyClassLoader
    at com.test.main(test.java:21)

2、链接

链接，是指将创建成的类合并至 Java 虚拟机中，使之能够执行的过程。它可分为验证、准备以及解析三个阶段。

• 验证：确保被加载类能够满足 Java 虚拟机的约束条件
• 准备：准备阶段的目的，
  • 　则是为被加载类的静态字段分配内存并初始化为默认值 比如一些基本数据类型，int默认值为0，long默认是0L等（但是没有真正初始化）。Java 代码中对静态字段的具体初始化，则会在稍后的初始化阶段中进行。
  • 还会构造与该类相关联的方法表。
• 解析（非必须，只有有符号引号需要转换的时候才有）：解析阶段的目的，正是将这些符号引用解析成为实际引用。如果符号引用指向一个未被加载的类，或者未被加载类的字段或方法，那么解析将触发这个类的加载（但未必触发这个类的链接以及初始化。）
  • 举例来说，对于一个方法调用，编译器会生成一个包含目标方法所在类的名字、目标方法的名字、接收参数类型以及返回值类型的符号引用，来指代所要调用的方法。

3、初始化（房子装修之后才可以入驻）

类加载的最后一步是初始化，初始化便是为标记为静态常量值（static final）的字段赋值，以及执行 < clinit > 方法的过程。Java 虚拟机会通过加锁来确保类的 < clinit > 方法仅被执行一次。

• 如果直接赋值的静态字段被 final 所修饰，并且它的类型是基本类型或字符串时，那么该字段便会被 Java 编译器标记成常量值（ConstantValue），其初始化直接由 Java 虚拟机完成。
• 除此之外的直接赋值操作，以及所有静态代码块中的代码，则会被 Java 编译器置于同一方法中，并把它命名为 < clinit >。

 那么，类的初始化何时会被触发呢？JVM 规范枚举了下述多种触发情况：

• 当虚拟机启动时，初始化用户指定的主类；
• 当遇到用以新建目标类实例的 new 指令时，初始化 new 指令的目标类；
• 当遇到调用静态方法的指令时，初始化该静态方法所在的类；
• 当遇到访问静态字段的指令时，初始化该静态字段所在的类；
• 子类的初始化会触发父类的初始化；
• 如果一个接口定义了 default 方法，那么直接实现或者间接实现该接口的类的初始化，会触发该接口的初始化；
• 使用反射 API 对某个类进行反射调用时，初始化这个类；
• 当初次调用 MethodHandle 实例时，初始化该 MethodHandle 指向的方法所在的类。

例子: // 著名的单例延迟初始化例子，只有当调用 Singleton.getInstance 时，程序才会访问 LazyHolder.INSTANCE，才会触发对 LazyHolder 的初始化（对应第 4 种情况），继而新建一个 Singleton 的实例。

　　// 由于类初始化是线程安全的，并且仅被执行一次，因此程序可以确保多线程环境下有且仅有一个 Singleton 实例。 （单例模式）

public class Singleton {
  private Singleton() {}
  private static class LazyHolder {
    static final Singleton INSTANCE = new Singleton();
  }
  public static Singleton getInstance() {
    return LazyHolder.INSTANCE;
  }
}

三、自定义类加载器

常见用途：将一个class用特定规则加密，然后在自定义的ClassLoader进行解密后在程序中加载使用。只有在我们自定义的加载器里能解密，提高了程序安全性。

自定义classLoader建议--覆盖findClass()方法，而不要直接改写loadClass()方法。

1、如果不想打破双亲委派模型，那么只需要重写findClass方法即可（一般选择这个）

2、如果想打破双亲委派模型，那么就重写整个loadClass方法

步骤：

    1. 编写一个类继承自ClassLoader抽象类。
    2. 复写它的findClass()方法。
    3. 在findClass()方法中调用defineClass()。 // // defineClass方法将字节码转化为类

先看一下ClassLoader里面的核心方法：

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 {
　　　　　　　　　　　　　　// 否则，会继续向上委派，若委派到启动类加载器仍然未能加载，则使用当前类加载器（findClass）进行加载。
                    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.
                    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;
        }
    }

例：自定义类加载器

package javap.loader;

import java.io.File;
import java.io.FileInputStream;

public class MyClassLoader extends ClassLoader{

    /**
     * class文件所在路径
     */
    private String classPath;


    public MyClassLoader(String classPath) {
        this.classPath = classPath;
    }

    public MyClassLoader(ClassLoader parent, String classPath) {
        super(parent);
        this.classPath = classPath;
    }

    /**
     * 覆盖findClass()方法，而不要直接改写loadClass()方法
     * @param name
     * @return
     * @throws ClassNotFoundException
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {

       // System.out.println("in MyClassLoader$findClass");
        //return null;

        // （1）加载class文件转为byte[]
        byte[] classBytes = readClass(name);
        if (classBytes != null) {
            // （2）byte[]转换为class，即调用defineClass
            return defineClass(name, classBytes, 0, classBytes.length);
        }

        return super.findClass(name);
    }


    /**
     * class文件读入为byte[]数组
     * @param className
     * @return
     */
    private byte[] readClass(String className) {
        try {

            String path = classPath + File.separatorChar + className.replace('.', File.separatorChar) + ".class";

            FileInputStream fis = new FileInputStream(path);
            int len = fis.available();
            byte[] data = new byte[len];
            fis.read(data);
            fis.close();
            return data;

        } catch (Exception e) {
            return null;
        }
    }
}

要被加载的类：

package javap.loader;

public class Test {
    public void say(String classLoadName){
        System.out.println("In Test: Hello " + classLoadName);
    }
}

测试入口类:

package javap.loader;

import java.lang.reflect.Method;

public class TestMyClassLoader {

    public static void main(String[] args) {

        try {
            /**
             * 个人的经验来看，最容易出问题的点是第27（33）行的打印出来的是"sun.misc.Launcher$AppClassLoader"。
             * 造成这个问题的关键在于idea是自动编译的，Test.java这个类在ctrl+S保存之后或者在Test.java文件不编辑若干秒后，
             * MyEclipse会帮我们用户自动编译Test.java，并生成到CLASSPATH也就是target目录下。在CLASSPATH下有Test.class，
             * 那么自然是由Application ClassLoader来加载这个.class文件了。
             */
            // 自定义类加载器（参数为class文件路径）
            MyClassLoader myClassLoader = new MyClassLoader(ClassLoader.getSystemClassLoader().getParent(), "/Users/**/work/code/testDemo/src/main/java/");

            // (1)用loadClass加载， 指定完整的包名+类名
            Class c1 = myClassLoader.loadClass("javap.loader.Test");
            if (c1 == null) {
                return;
            }
            // c1 != null
            Object obj1 = c1.newInstance();
            Method method1 = c1.getMethod("say", new Class[]{String.class});
            method1.invoke(obj1, "[c1]" + c1.getClassLoader().toString());

            // (2)Class.forName也可以指定类加载器
            Class c2 = Class.forName("javap.loader.Test", true, myClassLoader);
            Object obj2 = c2.newInstance();
            Method method2 = c2.getMethod("say", new Class[]{String.class});
            method2.invoke(obj2, "[c2]" + c2.getClassLoader().toString());


            // 用应用程序类加载器 sun.misc.Launcher$AppClassLoader
            Class c3 = Class.forName("javap.loader.Test");
            Object obj3 = c3.newInstance();
            Method method3 = c3.getMethod("say", new Class[]{String.class});
            method3.invoke(obj3, "[c3]" + c3.getClassLoader().toString());

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

结果：

In Test: Hello [c1]javap.loader.MyClassLoader@4b67cf4d
In Test: Hello [c2]javap.loader.MyClassLoader@4b67cf4d
In Test: Hello [c3]sun.misc.Launcher$AppClassLoader@135fbaa4

https://zhuanlan.zhihu.com/p/72066969

四、类加载过程初始化顺序

例1：

package javap.loader;

/**
 *    控制台打印
 */
class Log{
    public static String baseFieldInit(){System.out.println("Base:Normal Field");return "";}

    public static String baseStaticFieldInit(){System.out.println("Base:Static Field");return "";}

    public static String fieldInit(){System.out.println("Derived:Normal Field");return "";}

    public static String staticFieldInit(){System.out.println("Derived:Static Field");return "";}
}
/**
 *    基类
 */
class Base {
    /*1*/ static {System.out.println("Base:Static Block 1");}

    /*1*/ private static String staticValue=Log.baseStaticFieldInit();

    /*1*/ static {System.out.println("Base:Static Block 2");}

    /*3*/ {System.out.println("Base:Normal Block 1");}

    /*3*/ private String value=Log.baseFieldInit();

    /*3*/ {System.out.println("Base:Normal Block 2");}

    /*4*/ Base(){System.out.println("Base:Constructor");}
}
/**
 *    派生类
 */
public class Derived extends Base{

    /*2*/ static {System.out.println("Derived:Static Block 1");}

    /*2*/ private static String staticValue=Log.staticFieldInit();

    /*2*/ static {System.out.println("Derived:Static Block 2");}

    /*5*/ {System.out.println("Derived:Normal Block 1");}

    /*5*/ private String value=Log.fieldInit();

    /*5*/ {System.out.println("Derived:Normal Block 2");}

    /*6*/ Derived(){System.out.println("Derived:Derived Constructor");}



    /**
     *  MAIN 主线程
     */
    public static void main(String[] args){
        Derived d=new Derived();
    }
}

结果：

Base:Static Block 1
Base:Static Field
Base:Static Block 2
Derived:Static Block 1
Derived:Static Field
Derived:Static Block 2
Base:Normal Block 1
Base:Normal Field
Base:Normal Block 2
Base:Constructor
Derived:Normal Block 1
Derived:Normal Field
Derived:Normal Block 2
Derived:Derived Constructor

解释：

init是对象构造器方法，也就是说在程序执行 new 一个对象调用该对象类的 constructor 方法时才会执行init方法，而clinit是类构造器方法，也就是在jvm进行类加载—–验证—-解析—–初始化，中的初始化阶段jvm会调用clinit方法。(查看)

• 子类构造方法 Method "<init>":"()V" 内部执行逻辑，new对象时候执行
  • 执行父类的构造方法  invokespecial Method Base."<init>":"()V";
  • 按顺序初始化 非静态属性（非静态代码库）
• 静态块（属性）初始化方法：static Method "<clinit>":"()V" 内部执行逻辑，类加载的初始化阶段执行
  • 按顺序初始化 静态属性（静态代码库）

MacBook-Pro-2:loader$ java -jar ../asmtools.jar jdis  Derived.class 
package  javap/loader;

super public class Derived
        extends Base
        version 52:0
{

private static Field staticValue:"Ljava/lang/String;";
private Field value:"Ljava/lang/String;";

Method "<init>":"()V"
        stack 2 locals 1
{
                aload_0;
                invokespecial   Method Base."<init>":"()V";   // （1）调用父类构造方法
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "Derived:Normal Block 1";  // （2）初始化非静态块
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                aload_0;
                invokestatic    Method Log.fieldInit:"()Ljava/lang/String;";
                putfield        Field value:"Ljava/lang/String;";     // （2）初始化非静态属性
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "Derived:Normal Block 2";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "Derived:Derived Constructor";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                return;
        
}

public static Method main:"([Ljava/lang/String;)V"
        stack 2 locals 2
{
                new     class Derived;
                dup;
                invokespecial   Method "<init>":"()V";
                astore_1;
                return;
        
}

static Method "<clinit>":"()V"
        stack 2 locals 0
{
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "Derived:Static Block 1";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                invokestatic    Method Log.staticFieldInit:"()Ljava/lang/String;";
                putstatic       Field staticValue:"Ljava/lang/String;";
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "Derived:Static Block 2";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                return;
}

} // end Class Derived
MacBook-Pro-2:loader$ java -jar ../asmtools.jar jdis  Base.class
package  javap/loader;

super class Base
        version 52:0
{

private static Field staticValue:"Ljava/lang/String;";
private Field value:"Ljava/lang/String;";

Method "<init>":"()V"
        stack 2 locals 1
{
                aload_0;
                invokespecial   Method java/lang/Object."<init>":"()V";
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "Base:Normal Block 1";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                aload_0;
                invokestatic    Method Log.baseFieldInit:"()Ljava/lang/String;";
                putfield        Field value:"Ljava/lang/String;";
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "Base:Normal Block 2";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "Base:Constructor";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                return;
        
}

static Method "<clinit>":"()V"
        stack 2 locals 0
{
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "Base:Static Block 1";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                invokestatic    Method Log.baseStaticFieldInit:"()Ljava/lang/String;";
                putstatic       Field staticValue:"Ljava/lang/String;";
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "Base:Static Block 2";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                return;
}

} // end Class Base

结果证明：
对象在class文件加载完毕，以及为各成员在方法区开辟好内存空间之后，就开始所谓“初始化”的步骤：
1. 基类静态代码块，基类静态成员字段 （并列优先级，按代码中出现先后顺序执行）（只有第一次加载类时执行）
2. 派生类静态代码块，派生类静态成员字段 （并列优先级，按代码中出现先后顺序执行）（只有第一次加载类时执行）
3. 基类普通代码块，基类普通成员字段 （并列优先级，按代码中出现先后顺序执行）
4. 基类构造函数
5. 派生类普通代码块，派生类普通成员字段 （并列优先级，按代码中出现先后顺序执行）
6. 派生类构造函数

例2：

package javap.loader;


/**
 * 解释：根据类加载的顺序，以下两步在做的事情
 * 2、链接阶段：为被加载的静态字段分配内存（使用默认值0，并未真正初始化）
 * 3、初始化阶段：从静态代码块，基类静态成员字段进行初始化 （并列优先级，按代码中出现先后顺序执行）（只有第一次加载类时执行）
 *
 * 因此，main函数执行时候，为被加载的静态字段分配内存
 */
public class StaticTest {

    public static int k = 203;
    // public static int i = print("i_go");

    public static StaticTest t1 = new StaticTest("t1");
    public static StaticTest t2 = new StaticTest("t2");
    public static int i = print("i_go");
    public static int n = 99;
    public int j = print("j_yes");

    {
        print("构造块");
    }

    static{
        print("静态块");
    }

    public StaticTest(String str) {
        System.out.println((++k) + ":" + str + "-StaticTest-i=" + i + " n=" + n + ", t1=" + t1 + ", t2=" + t2);
        ++n;
        ++i;
    }

    public static int print(String str) {
        System.out.println((++k) + ":" + str + "-print-i=" + i + " n=" + n + ", t1=" + t1 + ", t2=" + t2);
        ++i;
        return ++n;
    }

    public static void main(String[] args) {
        StaticTest t = new StaticTest("init");
    }

}

执行结果：

204:j_yes-print-i=0 n=0, t1=null, t2=null
205:构造块-print-i=1 n=1, t1=null, t2=null
206:t1-StaticTest-i=2 n=2, t1=null, t2=null
207:j_yes-print-i=3 n=3, t1=javap.loader.StaticTest@2503dbd3, t2=null
208:构造块-print-i=4 n=4, t1=javap.loader.StaticTest@2503dbd3, t2=null
209:t2-StaticTest-i=5 n=5, t1=javap.loader.StaticTest@2503dbd3, t2=null
210:i_go-print-i=6 n=6, t1=javap.loader.StaticTest@2503dbd3, t2=javap.loader.StaticTest@4b67cf4d
211:静态块-print-i=7 n=99, t1=javap.loader.StaticTest@2503dbd3, t2=javap.loader.StaticTest@4b67cf4d
212:j_yes-print-i=8 n=100, t1=javap.loader.StaticTest@2503dbd3, t2=javap.loader.StaticTest@4b67cf4d
213:构造块-print-i=9 n=101, t1=javap.loader.StaticTest@2503dbd3, t2=javap.loader.StaticTest@4b67cf4d
214:init-StaticTest-i=10 n=102, t1=javap.loader.StaticTest@2503dbd3, t2=javap.loader.StaticTest@4b67cf4d

执行结果分析：

五、类加载过程深入分析（加载、链接、初始化）

new LazyHolder()与new LazyHolder[2]对比

 

例1：

package javap.loader;

public class SingletonTest {
    private SingletonTest() {
    }

    private static class LazyHolder {
        static final SingletonTest INSTANCE = new SingletonTest();

        static {
            System.out.println("LazyHolder.<clinit>");
        }
    }

    public static Object getInstance(boolean flag) {
        if (flag) return new LazyHolder();  // 下一个例子把此处替换为 LazyHolder[2];
        return LazyHolder.INSTANCE;
    }

    public static void main(String[] args) {
        getInstance(true);
        System.out.println("----");
        getInstance(false);
    }
}

java -verbose:class javap.loader.SingletonTest （如下结果省略了前部分）

[Loaded java.security.UnresolvedPermission from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.security.BasicPermissionCollection from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded javap.loader.SingletonTest from file:/Users/wuxiong.wx/work/code/testDemo/src/main/java/]
[Loaded sun.launcher.LauncherHelper$FXHelper from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Class$MethodArray from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Void from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded javap.loader.SingletonTest$LazyHolder from file:/Users/wuxiong.wx/work/code/testDemo/src/main/java/]   // （1）加载
LazyHolder.<clinit>  //（2）初始化（静态块）—— 已经完成链接
----
[Loaded java.lang.Shutdown from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Shutdown$Lock from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]

$ java -jar ../asmtools.jar jdis SingletonTest.class
package  javap/loader;

super public class SingletonTest
        version 52:0
{


private Method "<init>":"()V"
        stack 1 locals 1
{
                aload_0;
                invokespecial   Method java/lang/Object."<init>":"()V";
                return;
}

public static Method getInstance:"(Z)Ljava/lang/Object;"
        stack 3 locals 1
{
                iload_0;
                ifeq    L13;
                new     class SingletonTest$LazyHolder;
                dup;
                aconst_null;
                invokespecial   Method SingletonTest$LazyHolder."<init>":"(Ljavap/loader/SingletonTest$1;)V";
                areturn;
        L13:    stack_frame_type same;
                getstatic       Field SingletonTest$LazyHolder.INSTANCE:"Ljavap/loader/SingletonTest;";
                areturn;
}

public static Method main:"([Ljava/lang/String;)V"
        stack 2 locals 1
{
                iconst_1;
                invokestatic    Method getInstance:"(Z)Ljava/lang/Object;";
                pop;
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "----";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                iconst_0;
                invokestatic    Method getInstance:"(Z)Ljava/lang/Object;";
                pop;
                return;
}

synthetic Method "<init>":"(Ljavap/loader/SingletonTest$1;)V"
        stack 1 locals 2
{
                aload_0;
                invokespecial   Method "<init>":"()V";
                return;
}

static synthetic InnerClass class SingletonTest$1;
private static InnerClass LazyHolder=class SingletonTest$LazyHolder of class SingletonTest;

} // end Class SingletonTest

$ java -jar ../asmtools.jar jdis SingletonTest$LazyHolder.class
package  javap/loader;

super class SingletonTest$LazyHolder
        version 52:0
{

static final Field INSTANCE:"Ljavap/loader/SingletonTest;";

private Method "<init>":"()V"
        stack 1 locals 1
{
                aload_0;
                invokespecial   Method java/lang/Object."<init>":"()V";
                return;
}

synthetic Method "<init>":"(Ljavap/loader/SingletonTest$1;)V"
        stack 1 locals 2
{
                aload_0;
                invokespecial   Method "<init>":"()V";
                return;
}

static Method "<clinit>":"()V"
        stack 3 locals 0
{
                new     class SingletonTest;
                dup;
                aconst_null;
                invokespecial   Method SingletonTest."<init>":"(Ljavap/loader/SingletonTest$1;)V";
                putstatic       Field INSTANCE:"Ljavap/loader/SingletonTest;";
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "LazyHolder.<clinit>";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                return;
}

static synthetic InnerClass class SingletonTest$1;
private static InnerClass LazyHolder=class SingletonTest$LazyHolder of class SingletonTest;

} // end Class SingletonTest$LazyHolder

例2：把16行的LazyHolder()替换为 LazyHolder[2]，则 java -verbose:class javap.loader.SingletonTest （如下结果省略了前部分）结果如下：

[Loaded java.security.BasicPermissionCollection from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded javap.loader.SingletonTest from file:/Users/wuxiong.wx/work/code/testDemo/src/main/java/]
[Loaded sun.launcher.LauncherHelper$FXHelper from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Class$MethodArray from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Void from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded javap.loader.SingletonTest$LazyHolder from file:/Users/wuxiong.wx/work/code/testDemo/src/main/java/]  // (1)加载
----                
LazyHolder.<clinit>  // (2)初始化（静态块）- 已经完成链接
[Loaded java.lang.Shutdown from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Shutdown$Lock from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]

$ java -jar ../asmtools.jar jdis SingletonTest.class
package  javap/loader;

super public class SingletonTest
        version 52:0
{


private Method "<init>":"()V"
        stack 1 locals 1
{
                aload_0;
                invokespecial   Method java/lang/Object."<init>":"()V";
                return;
}

public static Method getInstance:"(Z)Ljava/lang/Object;"
        stack 1 locals 1
{
                iload_0;
                ifeq    L9;
                iconst_2;
                anewarray       class SingletonTest$LazyHolder;
                areturn;
        L9:     stack_frame_type same;
                getstatic       Field SingletonTest$LazyHolder.INSTANCE:"Ljavap/loader/SingletonTest;";
                areturn;
}

public static Method main:"([Ljava/lang/String;)V"
        stack 2 locals 1
{
                iconst_1;
                invokestatic    Method getInstance:"(Z)Ljava/lang/Object;";
                pop;
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "----";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                iconst_0;
                invokestatic    Method getInstance:"(Z)Ljava/lang/Object;";
                pop;
                return;
}

synthetic Method "<init>":"(Ljavap/loader/SingletonTest$1;)V"
        stack 1 locals 2
{
                aload_0;
                invokespecial   Method "<init>":"()V";
                return;
}

static synthetic InnerClass class SingletonTest$1;
private static InnerClass LazyHolder=class SingletonTest$LazyHolder of class SingletonTest;

} // end Class SingletonTest

$ java -jar ../asmtools.jar jdis SingletonTest$LazyHolder.class
package  javap/loader;

super class SingletonTest$LazyHolder
        version 52:0
{

static final Field INSTANCE:"Ljavap/loader/SingletonTest;";

private Method "<init>":"()V"
        stack 1 locals 1            // stack 1 修改为 stack 0，然后去看下一个例子
{
                aload_0;
                invokespecial   Method java/lang/Object."<init>":"()V";
                return;
}

static Method "<clinit>":"()V"
        stack 3 locals 0
{
                new     class SingletonTest;
                dup;
                aconst_null;
                invokespecial   Method SingletonTest."<init>":"(Ljavap/loader/SingletonTest$1;)V";
                putstatic       Field INSTANCE:"Ljavap/loader/SingletonTest;";
                getstatic       Field java/lang/System.out:"Ljava/io/PrintStream;";
                ldc     String "LazyHolder.<clinit>";
                invokevirtual   Method java/io/PrintStream.println:"(Ljava/lang/String;)V";
                return;
}

private static InnerClass LazyHolder=class SingletonTest$LazyHolder of class SingletonTest;
static synthetic InnerClass class SingletonTest$1;

} // end Class SingletonTest$LazyHolder

例3：修改上述 SingletonTest$LazyHolder.class 字节码里面构造方法的 操作数栈大小为0（查看）

操作步骤：

1.  java -jar ../asmtools.jar jdis SingletonTest$LazyHolder.class > SingletonTest$LazyHolder.jasm.1
2.  cp  SingletonTest$LazyHolder.jasm.1  SingletonTest$LazyHolder.jasm
3. vi 打开 SingletonTest$LazyHolder.jasm修改
4. java -jar ../asmtools.jar jasm SingletonTest$LazyHolder.jasm 即重新更新字节码SingletonTest$LazyHolder.class

过程疑问及解答：

　　疑问：LazyHolder.INSTANCE应该是触发内部类LazyHolder的加载（其中的初始化步骤会执行<clinit>）；因为没有new LazyHolder()应该不会执行它的构造方法<init>啊，怎么会抛出异常呢??？

　　解答：应该是在“链接”的“验证”阶段，JVM发现<init>的操作数栈过小，直接验证不通过；

结论：

• new LazyHolder[2]：虚拟机必须知道（加载）有这个类，才能创建这个类的数组（容器），但是这个类并没有被使用到（没有达到初始化的条件），所以不会初始化。
• 新建数组的时候并不是要使用这个类（只是定义了放这个类的容器），所以不会被链接，调用getInstance(false)的时候约等于告诉虚拟机（即return LazyHolder.INSTANCE;）
  ，我要使用这个类了，你把这个类造好（链接），然后把static修饰的字符赋予变量（初始化）。

结果：

[Loaded java.security.UnresolvedPermission from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.security.BasicPermissionCollection from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded javap.loader.SingletonTest from file:/Users/wuxiong.wx/work/code/testDemo/src/main/java/]
[Loaded sun.launcher.LauncherHelper$FXHelper from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Class$MethodArray from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Void from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded javap.loader.SingletonTest$LazyHolder from file:/Users/wuxiong.wx/work/code/testDemo/src/main/java/]   
----
[Loaded java.lang.VerifyError from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
Exception in thread "main" [Loaded java.lang.Throwable$PrintStreamOrWriter from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Throwable$WrappedPrintStream from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.util.IdentityHashMap from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.util.IdentityHashMap$KeySet from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
java.lang.VerifyError: Operand stack overflow
Exception Details:
  Location:
    javap/loader/SingletonTest$LazyHolder.<init>()V @0: aload_0
  Reason:
    Exceeded max stack size.
  Current Frame:
    bci: @0
    flags: { flagThisUninit }
    locals: { uninitializedThis }
    stack: { }
  Bytecode:
    0x0000000: 2ab7 0006 b1                           

        at javap.loader.SingletonTest.getInstance(SingletonTest.java:17)
        at javap.loader.SingletonTest.main(SingletonTest.java:23)
[Loaded java.lang.Shutdown from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Shutdown$Lock from /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home/jre/lib/rt.jar]

读郑雨迪《深入拆解Java虚拟机》 -- 第三讲 Java虚拟机是如何加载Java类的 https://blog.csdn.net/Ti_an_Di/article/details/81415685