JVM学习-类加载过程(二)

丢爸

已于 2024-05-31 22:12:08 修改

阅读量1.4k

点赞数 26

分类专栏： java 文章标签： jvm 学习 java

于 2024-05-31 16:12:06 首次发布

本文链接：https://blog.youkuaiyun.com/xuwenpeng/article/details/139339391

版权

java 专栏收录该内容

55 篇文章

订阅专栏

Initialization初始化阶段

为类的静态变量赋予正确的初始值

具体描述

类的初始化是类装载的最后一个阶段，如果前面的步骤没有问题，那么表示类可以顺利装载到系统中，此时，类才会开始执行Java字节码(即，到了初始化阶段，才真正开始执行类中定义的Java代码)
初始化阶段的重要工作是执行类的初始化方法：()方法

该方法仅能由Java编译器生成并由JVM调用，程序开发者无法自定义一个同名方法，更无法直接在Java程序中调用该方法，虽然该方法也是由字节码指令所组成
它是由类静态成员的赋值语句以及static语句块合并产生的

说明

在加载一个类之前，虚拟机总是会试图加载该类的父类，因此父类的总是在子类之前被调用，也就是说，父类的static块优先级高于子类------(由父及子，静态先行)
Java编译器并不会为所有的类都产生初始化方法，有些类编译成字节码后，不会包含方法

一个类中并没有声明任何的类变量，也没有静态代码块时
一个类中声明类变量，但是没有明确使用类变量的初始化语句以及静态代码块来执行初始化操作时
一个类中包含static final修饰的基本数据类型的字段，这些类字段初始化语句采用编译时常量表达式

在这里插入图片描述

/**
 * 说明：使用static + final修饰的字段的显示赋值操作，到底是在哪个阶段进行的赋值
 * 情况1：在链接阶段的准备环节赋值
 * 情况2：在初始化阶段赋值
 *
 * 结论：在链接阶段的准备环节赋值
 * ①对于基本数据类型的字段来说，使用static final修饰，显示赋值(直接赋值常量，非调用方法)在链接阶段的准备环节赋值
 * ②对于String来说，如使用字面量赋值，使用static final修饰的话，显示赋值在链接阶段的准备环节赋值
 *
 * 初始化<clinit>()中赋值的情况
 * 排除上述在准备环节赋值的情况之外的情况
 * 最终结论：使用static + final修饰，且显示赋值不涉及到方法或构造调用的基本数据类型或String类型的显示赋值，是在链接阶段的准备环节进行
 */
public class InitializationTest2 {
    public static int a = 1;  //在初始化阶段<clinit>赋值
    public static final int INT_CONSTANT = 10;  //在链接阶段的准备环节赋值
    public static final Integer INTEGER_CONSTANT1 = Integer.valueOf(100);//在初始化阶段<clinit>赋值
    public static Integer INTEGER_CONSTANT2 = Integer.valueOf(1000);//在初始化阶段<clinit>赋值

    public static final String s1 = "helloworld1"; //在链接阶段的准备环节赋值
    public static final String s0 = new String("helloworld0");//在初始化阶段<clinit>赋值

    public static final int NUM1 = 2;//在链接阶段的准备环节赋值
    public static final int NUM2 = new Random().nextInt(10);//在初始化阶段<clinit>赋值
}
//字节码--<clinit>
 0 iconst_1
 1 putstatic #2 <com/chapter11/InitializationTest2.a>
 4 bipush 100
 6 invokestatic #3 <java/lang/Integer.valueOf>
 9 putstatic #4 <com/chapter11/InitializationTest2.INTEGER_CONSTANT1>
12 sipush 1000
15 invokestatic #3 <java/lang/Integer.valueOf>
18 putstatic #5 <com/chapter11/InitializationTest2.INTEGER_CONSTANT2>
21 new #6 <java/lang/String>
24 dup
25 ldc #7 <helloworld0>
27 invokespecial #8 <java/lang/String.<init>>
30 putstatic #9 <com/chapter11/InitializationTest2.s0>
33 new #10 <java/util/Random>
36 dup
37 invokespecial #11 <java/util/Random.<init>>
40 bipush 10
42 invokevirtual #12 <java/util/Random.nextInt>
45 putstatic #13 <com/chapter11/InitializationTest2.NUM2>
48 return

()线程安全性

对于()方法的调用，也就是类的初始化，虚拟机会在内部确保其多线程环境中的安全性
虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程会执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕
因为函数()带锁线程是安全的，如果一个类的()方法中有耗时很长的操作，就可能造成多个线程阻塞，引发死锁，并且这种死锁很难发现，因为看起来没有可用的锁信息
如果之前的线程成功加载了类，则等在队列中的线程就没有机会再执行()方法了，那么当需要使用这个类时，虚拟机会直接返回它已经准备好的信息

//死锁例子
class staticA {
    static {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {

        }
        try {
            Class.forName("com.chapter11.staticB");
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("StaticA init OK");
    }
}
class staticB {
    static {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {

        }
        try {
            Class.forName("com.chapter11.staticA");
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("StaticB init OK");
    }
}
public class StaticDeadLockMain extends Thread{
    private char flag;
    public StaticDeadLockMain(char flag) {
        this.flag = flag;
        this.setName("Thread" + flag);
    }

    @Override
    public void run() {
        try {
            Class.forName("com.chapter11.static" + flag);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        StaticDeadLockMain sdlm1 = new StaticDeadLockMain('A');
        StaticDeadLockMain sdlm2 = new StaticDeadLockMain('B');
        sdlm1.start();
        sdlm2.start();
    }
}

主动使用VS被动使用

主动使用

Class只有在必须首次使用的时候才会被装载，Java虚拟机不会无条件地装载Class类型，Java虚拟机规定，一个类或接口在初次使用前，必须进行初始化，这里指主动使用，主动使用有下面几种情况

当创建一个类的实例时，比如使用new关键字，通过反射，克隆，反序列化
当调用类的静态方法时，即当使用了字节码invokestatic指令

package com.chapter11;

import org.junit.Test;

import java.io.*;

/**
 * 当创建一个类的实例时，比如使用new关键字，通过反射，克隆，反序列化
 * 当调用类的静态方法时，即当使用了字节码invokestatic指令
 */
class Order implements Serializable{
    static {
        System.out.println("Order类的初始化");
    }

    public static void method1() {
        System.out.println("order method1()... ...");
    }
}
public class ActiveUse1 {
    public static void main(String[] args) {
        Order order = new Order();
    }
    @Test
    //当调用类的静态方法时
    public void test3() {
        Order.method1();  //0 invokestatic #4 <com/chapter11/Order.method1>
    }
    //序列化过程
    @Test
    public void testSerializable() {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("order.dat"));
            oos.writeObject(new Order());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //反序列化
    @Test
    public void  testDeSerializable() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("order.dat"));
            Object o = ois.readObject();
            if (o instanceof Order) {
                Order order = (Order) o;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

当使用类，接口的静态字段时(finl特殊考虑)，如getstatic或putstatic指令(对应访问变量，赋值变量)

class User {
    public static int num = 1;
    public static final int num1 = 2;
    public static final int num2 = new Random().nextInt(10);

    static {
        System.out.println("User类初始化");
    }
}

interface CompareA {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareA的初始化");
        }
    };
    public static final int NUM1 = 1;
    public static final int NUM2 = new Random().nextInt(10);
}

public class ActiveUser2 {
    /**
     * 执行结果--执行clinit
     * User类初始化
     * 1
     */
    @Test
    public void test1() {
        System.out.println(User.num);
    }

    /**
     * 执行结果--不执行clinit
     * 1
     */
    @Test
    public void test2() {
        System.out.println(User.num1);
    }

    /**
     * 执行结果--会执行clinit
     * User类初始化
     * 7
     */
    @Test
    public void test3() {
        System.out.println(User.num2);
    }

    /**
     * 执行结果
     *  1
     */
    @Test
    public void test4() {
        System.out.println(CompareA.NUM1);
    }
    /**
     * 执行结果
     *  CompareA的初始化
     *  9
     */
    @Test
    public void test5() {
        System.out.println(CompareA.NUM2);
    }
}

当使用java.lang.reflect包中的方法反射类的方法时，如Class.forName(“className”)

public class ActiveUse3 {
    /**
     * 此处使用的Order为ActiveUse1中的Order类
     * 执行结果
     * Order类的初始化
     */
    @Test
    public void test1() {
        try {
            Class<?> clazz = Class.forName("com.chapter11.Order");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

X当初始化子类时，发现父类没有初始化，需要触发其父类的初始化

 /**
     * 执行结果
     * Father类的初始化过程
     * Son类的初始化过程
     * 1
     */
    @Test
    public void test2() {
        System.out.println(Son.num);
    }
class Father {
    static {
        System.out.println("Father类的初始化过程");
    }
}
class Son extends Father {
    static {
        System.out.println("Son类的初始化过程");
    }
    public static int  num = 1;
}

一个接口定义了default方法，那直接实现或间接实现该接口类的初始化，该接口要在其之前被初始化
当虚拟机启动时，用户需要指定一个要执行的主类(包含main方法的那个类)，虚拟机会先初始化这个主类
当初次调用MethodHandle实例时，初始化该MethodHandle指向的方法所在的类(涉及解析REF_getStatic,REF_putStatic,REF_invokeStatic方法句柄对应的类)

针对X项的补充，当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但这条规则不适用于接口

在初始化一个类时，并不会先初始化它所实现的接口
在初始化一个接口时，并不会先初始化它的父接口

 /**
     * Father类的初始化过程--(初始化类时，并不会先初始化它所实现的接口)
     * Son类的初始化过程
     * 1
     */
    @Test
    public void test3() {
        System.out.println(Son.num);
    }

    /**
     * 执行结果
     * CompareC的初始化---初始化一个接口时，不会初始化它的父接口
     */
    @Test
    public void test4() {
        System.out.println(compareC.num1);
    }
}
class Father {
    static {
        System.out.println("Father类的初始化过程");
    }
}
class Son extends Father implements compareB{
    static {
        System.out.println("Son类的初始化过程");
    }
    public static int  num = 1;
}
interface compareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareB的初始化");
        }
    };
}
interface compareC extends compareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareC的初始化");
        }
    };
    int num1 = new Random().nextInt(10);
}

因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化，只有当程序员首次使用特定接口的静态字段时，才会导致该接口的初始化

 @Test
    public void test5() {
        System.out.println(Son.num);
    }
class Father {
    static {
        System.out.println("Father类的初始化过程");
    }
}
class Son extends Father implements compareB{
    static {
        System.out.println("Son类的初始化过程");
    }
    public static int  num = 1;
}
interface compareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareB的初始化");
        }
    };
    public default void method1() {
        System.out.println("compareB--method1");
    }
}
//执行结果
Father类的初始化过程
CompareB的初始化
Son类的初始化过程
1

针对JDK7，JVM启动的时候通过引导类加载器加载一个初始类，这个类在调用public static void main(String[] args)方法之前被链接和初始化，这个方法的执行将依次导致所需的类的加载，链接和初始化。

被动使用

被动使用不会引起类的初始化，并不是代码中出现的类，就一定会被加载或者初始化。如果不符合主动使用的条件，类就不会初始化

当访问一个静态字段时，只有真正声明这个字段的类才会被初始化

当通过子类引用父类的静态变量，不会导致此类的初始化

通过数组定义类引用，不会触发此类的初始化

package com.chapter11;

import org.junit.Test;

/**
 * Administrator
 * 2024/5/31
 */
class Parent {
    static {
        System.out.println("Parent初始化");
    }
    public static int num = 1;
}
class Child extends Parent {
    static {
        System.out.println("Child初始化");
    }
}
public class PassiveUse1 {
    /**
     * 注：没有初始化不代表没有加载
     * 执行结果
     * Parent初始化
     * 1
     */
    @Test
    public void test1() {
        System.out.println(Child.num);
    }

    /**
     * 执行结果
     * 空
     */
    @Test
    public void test2() {
        Parent[] parents = new Parent[10];
    }

    /**
     * * 执行结果
     *   Parent初始化
     */
    @Test
    public void test3() {
        Parent[] parents = new Parent[10];
        parents[0] = new Parent();
    }
}

引用常量不会触发此类或接口的初始化，因为常量在链接阶段就已经被显示赋值了

class Person {
    static {
        System.out.println("Person类的初始化");
    }
    public final static int NUM = 1;
    public final static int NUM1 = new Random().nextInt(10);
}
public class PassiveUse2 {

    /**
     * 执行结果--没有执行初始化
     * 1
     */
    @Test
    public void test1() {
        System.out.println(Person.NUM);
    }
    /**
     * 执行结果
     * Person类的初始化
     * 1
     */
    @Test
    public void test2() {
        System.out.println(Person.NUM1);
    }
    /**
     * 执行结果
     * 2
     */
    @Test
    public void test3() {
        System.out.println(SerialA.NUM1);
    }
    /**
     * 执行结果
     * SerialA的初始化
     * 5
     */
    @Test
    public void test4() {
        System.out.println(SerialA.NUM2);
    }
}
interface SerialA {
    public static final Thread t = new Thread() {
        {
            System.out.println("SerialA的初始化");
        }
    };
    int NUM1 = 2;
    int NUM2 = new Random().nextInt(10);   //赋值操作需要在clinit中执行
}

调用ClassLoader类的loadClass()方法加载一个类，并不对类的主动使用，不会导致类的初始化

//执行结果为空，表示没有显示初始化类
@Test
    public void test5() {
        try {
            Class<?> clazz = ClassLoader.getSystemClassLoader().loadClass("com.chapter11.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

类的Using(使用)

开发人员可以在程序中访问和调用它的静态类成员信息(静态字段、静态方法)，或者使用new关键字为其创建对象实例

类的Unloading(卸载)

方法区的垃圾回收

类、类加载器、类实例之前的引用关系

在类加载器的内部实现中，用一个Java集合来存放所加载类的引用，另一方面，一个Class对象总是会引用它的类加载器，调用Class对象的getClassLoader()方法，就能获得它的类加载器，由此可见，代表某个类的Class实例与其类的加载器之前为双向关联关系
一个类的实例总是引用代表这个类的Class对象。在Object类中定义了getClass()方法，这个方法返回代表对象所属类的Class对象的引用，此外，所有的Java类都有一个静态属性class,它引用代表这个类的Class对象

类的生命周期

当Sample类被加载、链接、初始化后，它的生命周期就开始了，当代表Sample类的class对象不再被引用，即不可触及时，Class对象就会结束生命周期，Sample类在方法区内的数据也会被卸载，从而结束Sample类的生命周期
一个类何时结束生命周期，取决于代表它的Class对象何时结束生命周期
loader1变量和obj变量间接应用代表Sample类的Class对象，而objClass变量则直接引用它
如果程序运行过程中，将上图左侧三个引用变量置为null,此时sample对象结束生命周期，MyClassLoader对象结束生命周期，代表Sample类的Class对象也结束生命周期，Sample类在方法区内的二进制数据被卸载
当再次有需要时，会检查Sample类的Class对象是否存在，如果存在则直接使用，不再重新加载，如果不存在Sample类会被重新加载，在Java虚拟机的堆区会生成一个新的代表Sample类的Class实例

类的卸载

启动类加载器加载的类型在整个运行期间是不可能被卸载的(jvm和jls规范)
被系统类加载器和扩展类加载器加载的类型在运行期间不太可能被卸载，因为系统类加载器实例或者扩展类的实例基本上在整个运行期间总能直接或间接的访问到，其达到unreachable的可能性小
被开发者自定义的类加载器实例加载的类型只有在很简单的上下文环境中才能被卸载，而且一般还要借助于强制调用虚拟机的垃圾收集功能才可以做到，可以预想，稍微复杂点的应用场景中，被加载的类型在运行期间也是几乎不太可能被卸载的
综上几点，一个已经加载的类型被卸载的几率很小至少被卸载的时间是不确定的，同时可以看出，开发者在开发代码时，不应该对虚拟机的类型卸载做任何假设的前提下，来实现系统中的特定功能