虚拟机类加载机制

Java虚拟机 | Apr 21, 2018

加载

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

准备

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。
这时候进行内存分配的仅包含类变量（被static修饰的变量），而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在Java堆中。其次，这里所说的初始值“通常情况”下是数据类型的零值，假设一个类型变量定义为：
public static int value = 100;
那变量value在准备阶段过后的初始值为0而不是100，因为这时候尚未开始执行任何Java方法，而把value赋值为100的putstatic指令是程序被编译后，存放于类构造器<clinit>()方法之中，所以把value赋值为100的动作将在初始化阶段才会执行。

如果类字段的字属性表中存在ConstantValue属性，那再准备阶段变量value就会被初始化为ConstantValue属性所指定的值，假设一个类型变量定义为：
public static final int value = 100;
编译时Javac将会为value生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue的设置将value赋值为100。

验证

验证的过程只要是保证 class 文件的安全性和正确性，确保加载了该 class 文件不会导致 JVM 出现任何异常，不会危害JVM 的自身安全。验证包括对文件格式、元数据和字节码的验证。

准备

准备阶段是为类变量进行内存分配和初始化零值的过程。注意这时候分配的是类变量的内存，这些内存会在方法区中分配。此时不会分配实例变量的内存，因为实例变量是在实例化对象时一起创建在Java堆中的。而且此时类变量是赋值为零值，即 int 类型的零值为 0，引用类型零值为 null，而不是代码中显示赋值的数值。

解析

解析阶段是虚拟机将常量池中的符号引用转化为直接引用的过程。在 class 文件中常量池里面存放了字面量和符号引用，符号引用包括类和接口的全限定名以及字段和方法的名称与描述符。在 JVM 动态链接的时候需要根据这些符号引用来转换为直接引用存放内存使用。

初始化

遇到new、getstatic、putstatic或invokestatic这4条字节码指令时，如果类没有经过初始化，则需要先触发其初始化。最常见的Java代码场景是：使用new关键字实例化对象的时候、读取或设置一个类的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。
使用java.lang.reflect包的方法对类进行反射调用的时候。
当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
当虚拟机启动时，用户需要制定一个执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主。
当使用JDK1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化。

public class SuperClass {

    static {
        System.out.println("SuperClass init!");
    }

    public static int value = 123;
}

public class SubClass extends SuperClass {

    static {
        System.out.println("SubClass init!");
    }
}

public class NotInitialization {

    public static void main(String[] args) {
        // 被动引用的例子之一
        // 对于静态字段，只有直接定义这个字段的类才会被初始化。
        System.out.println(SubClass.value);
        // SuperClass init!
        // 123

        // 被动引用的例子之二
        // 通过数组定义来引用类，不会触发此类的初始化
        SuperClass[] sca = new SuperClass[10];

        // 被动引用的例子之三
        // 常量在编译阶段会存入调用类的常量池，本质上并没有直接引用到定义常量的类，因此不会触发此类的初始化
        System.out.println(SuperClass.HELLO_WORLD);

        // 一个接口在初始化时，并不要求其父接口全部都完成初始化，只有在真正使用到父接口的时候（如引用接口中定义的常量）才会初始化。
    }
}

类加载器

对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类命名空间。

public class ClassLoaderTest {
    public static void main(String[] args) throws Exception {
        // 构造一个简单的类加载器
        ClassLoader myClassLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                try {
                    String filename = name.substring(name.lastIndexOf(".") + 1) + ".class";
                    InputStream is = getClass().getResourceAsStream(filename);
                    if (is == null) {
                        return super.loadClass(name);
                    }
                    byte[] bytes = new byte[is.available()];
                    is.read(bytes);
                    return defineClass(name, bytes, 0, bytes.length);
                } catch (IOException e) {
                    throw new ClassNotFoundException(name);
                }
            }
        };
        // 使用自定义类加载器实例化类 "com.junhc.ClassLoaderTest" 对象
        Object o = myClassLoader.loadClass("com.junhc.ClassLoaderTest").newInstance();
        System.out.println(o.getClass());
        // 虚拟机中存在两个 ClassLoaderTest 类，一个是由系统应用程序类加载器加载的，另外一个由
        // 我们自定义的类加载的，虽然都来自同一个class文件，但依然是两个独立的类，做对象所属类型
        // 检查时结果为false
        System.out.println(o instanceof com.junhc.ClassLoaderTest);
        //
        System.out.println(o.getClass().getClassLoader().getClass().getName());
        System.out.println(ClassLoaderTest.class.getClassLoader().getClass().getName());
        System.out.println(System.class.getClassLoader());
        System.out.println(List.class.getClassLoader());
        //
        ClassLoader cl = ClassLoaderTest.class.getClassLoader();
        while(cl != null){
            System.out.print(cl.getClass().getName()+"->");
            cl = cl.getParent();
        }
        System.out.println(cl);
    }
}

//class com.junhc.ClassLoaderTest
//false
//com.junhc.ClassLoaderTest$1
//sun.misc.Launcher$AppClassLoader
//null
//null
//sun.misc.Launcher$AppClassLoader->sun.misc.Launcher$ExtClassLoader->null

双亲委派模型

▣ 启动类加载器 (Bootstarp ClassLoader): 这个类将负责存放在 <JAVA_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中，并且虚拟机识别的类库加载到虚拟机内存中。启动类加载器无法被Java程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给引导类加载器，那么直接使用null代替即可。

▣ 扩展类加载器 (Extension ClassLoader): 这个加载器由 sum.misc.Launcher$ExtClassLoader 实现，它负责加载 <JAVA_HOME>\lib\ext 目录中的，或者被java.ext.dirs系统变量所指定的路径中的所有类库，开发者可以直接使用扩展类加载器。

▣ 应用程序类加载器 (Application ClassLoader): 这个类加载由 sum.misc.Launcher$AppClassLoader 实现。由于这个类加载器是 CLassLoader 中的 getSystemClassLoader() 方法的返回值，所以一般也称它为系统类加载器。它负责加载用户类路径 classpath 上所指定的类库，开发者可以直接使用这个类加载器，一般情况下这个就是程序中默认的类加载器。

除此之外，还有自定义的类加载器，它们之间的层次关系被称为类加载器的双亲委派模型。该模型要求除了顶层的启动类加载器外，其余的类加载器都应该有自己的父类加载器，而这种父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）。

双亲委派模型的工作过程: 如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到的顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求 (它的搜索范围中没有找到所需的类) 时，子加载器才会尝试自己去加载。使用双亲委派模型来组织类加载器之间的关系，有一个显而易见的好处就是Java类随着它的类加载器一起具备了一种带有优先级的层次关系。

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
                // 说明父类加载器无法完成加载请求
            }

            if (c == null) {
                // 在父类加载器无法加载的时候
                // 再调用本身的 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;
    }
}

举个栗子

public class StaticTest {

    public static void main(String[] args) {
        // 类的准备阶段
        // 类的初始化阶段
        staticFunc();
    }

    static StaticTest st = new StaticTest();

    static {
        System.out.println("1");
    }

    {
        System.out.println("2");
    }

    StaticTest() {
        System.out.println("3");
        System.out.println("a=" + a + ",b=" + b);
    }

    public static void staticFunc() {
        System.out.println("4");
        //System.out.println("b=" + b);
    }

    int a = 100;
    static int b = 200;
}
//输出结果如下
2
3
a=100,b=0
1
4

Junhc

岂止于博客

虚拟机类加载机制

目录

加载

准备

验证

准备

解析

初始化

类加载器

双亲委派模型

举个栗子

虚拟机类加载机制

目录

加载

准备

验证

准备

解析

初始化

类加载器

双亲委派模型

举个栗子

相关文章