JVM进阶之类加载过程详解(下篇)

Posted 2021-12-12 ProChick

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JVM进阶之类加载过程详解(下篇)相关的知识，希望对你有一定的参考价值。

类加载过程详解下篇

一、类的初始化阶段

1.初始化方法

类的初始化是类装载的最后一个阶段，如果前面的步骤都没有问题，那么表示类可以顺利装载到系统中，此时类才会开始执行Java字节码。

初始化阶段的工作是执行类的初始化方法<clinit>()，完成类中静态成员变量或者静态代码块的显式赋值。

public class Test{
    public static int id = 1;
    public static int number;
    
    static{
        number = 2;
    }
}

类的初始化方法仅能由Java编译器生成并由Java虚拟机调用，开发者则无法自定义一个同名的方法，更无法直接在Java程序中调用该方法，虽然该方法也是由字节码指令所组成。

在加载一个类之前，Java虚拟机总是会试图加载该类的父类，因此父类的初始化方法总是在子类初始化之前被调用。

public class Father{
    public static int id = 1;
    public static int number;
    
    static{
        number = 2;
        System.out.println("father static{}");
    }
}

public class Son extends Father{
    static{
        number = 4;
        System.out.println("son static{}");
    }
    
    public static void main(String[] args) {
        System.out.println(number);
    }
}

Java编译器并不会为所有的类都产生clinit()初始化方法，比如：
- 一个类中没有声明任何的静态成员变量，也没有静态代码块时
```
public class Test{
    public int num = 1;
}
```
- 一个类中声明了静态成员变量，但是没有为该变量进行初始化赋值，也没有在静态代码块中初始化时
```
public class Test{
    public static int num;
}
```
- 一个类中包含static final修饰的基本数据类型的字段，这些类字段初始化语句采用编译时常量表达式时
```
public class Test{
  public static final int num = 1;
}
```

2.初始化过程

对于类变量的赋值操作，通常会发在两个阶段，一种是在链接的准备阶段进行显式赋值，一种是在初始化阶段进行显式赋值。
如果变量被static final所修饰，并且是下面情况中的一种，那么赋值就是在链接的准备阶段进行。
- 变量是基本数据类型，而且显式赋值中不涉及到方法或构造器的调用
- 变量String字符串类型，而且显式赋值的是字面量
除了上面之外的情况，其它的被static所修饰或者被static final所修饰的变量的赋值通常就是在初始化阶段进行。

代码示例

public class Test {
    // 在初始化阶段赋值
    public static int a = 10;
    // 在链接的准备阶段赋值
    public static final int b = 10;
    // 在初始化阶段赋值
    public static final int c = new Random().nextInt(10);

    // 在初始化阶段赋值
    public static final Integer A = Integer.valueOf(100);
    // 在初始化阶段赋值
    public static Integer B = Integer.valueOf(100);

    // 在链接的准备阶段赋值
    public static final String s1 = "hello";
    // 在初始化阶段赋值
    public static final String s2 = new String("hello");    
}

3.类初始化方法的安全性

对于类初始化方法的调用，Java虚拟机会在内部确保其多线程环境中的安全性。
Java虚拟机会保证一个类的clinit()方法在多线程环境中能够被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的clinit()方法，其他线程都需要阻塞等待，直到活动的线程执行clinit()方法完毕。

也正是由于类初始化方法是线程安全的，因此，如果在一个类的clinit()方法中有耗时很长的操作，就可能造成多个线程阻塞引发死锁，并且这种死锁是很难发现的。

代码举例

class StaticA {
    static {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }
        try {
            Class.forName("com.dsh.jvmp2.chapter03.java1.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.dsh.jvmp2.chapter03.java1.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.dsh.jvmp2.chapter03.java1.Static" + flag);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(getName() + " over");
    }

    public static void main(String[] args) throws InterruptedException {
        StaticDeadLockMain loadA = new StaticDeadLockMain('A');
        loadA.start();
        StaticDeadLockMain loadB = new StaticDeadLockMain('B');
        loadB.start();
    }
}

从上面的代码中，我们看到：loadA线程加载了StaticA，StaticA加载了StaticB，loadB线程加载了StaticB，StaticB加载了StaticA。但由于StaticA和StaticB的静态代码块中都有1s的阻塞时间，所以当StaticA想要加载StaticB的时候，StaticB已经被loadB线程事先加载了，所以loadA线程需要等待StaticB。同理，loadB线程也会等待StaticA，从而出现了相互等待的情况(也就是死锁行为)。

4.类初始化的使用

Java程序对类的使用分为两种：主动使用和被动使用，它们的区别在于执不执行clinit()方法。

主动使用

类只有在首次被使用的时候才会被装载，Java虚拟机不会无条件地装载某个类，并且这个类在初次主动使用前，必须要进行初始化。主动使用的情况如下：

当创建一个类的实例时，比如：通过new关键字、通过反射、通过克隆、通过反序列化。

class Example implements Serializable, Cloneable{
    static {
        System.out.println("类初始化");
    }

    @Override
    public Object clone(){
        return super.clone();
    }
}

public class Test {
    public static void main(String[] args) {
        // new方式
        Example e1 = new Example();
        
        // 反射方式
        Class<?> result = Class.forName("Example");
        Example e2 = result.newInstance();
        
        // 克隆方式
        Example e3 = e1.clone();
        
        // 反序列化方式
        ObjectInputStream ois = 
            new ObjectInputStream(new FileInputStream("序列化的文件"));
        Example e3 = (Example) ois.readObject();
        ois.close();
    }
}

当调用类的静态方法时。

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

    public static void method(){
        
    }
}

public class Test {
    public static void main(String[] args) {
        Example.method();
    }
}

当调用类、接口的静态字段时（final修饰的特殊考虑）。

public class Test1{
    static {
        System.out.println("类初始化");
    }

    public static int num1 = 1;
    public static final int num2 = 1;
    public static final int num3 = new Random().nextInt(10);
}

public interface Test2{
    public static final Thread t = new Thread(){
        {
            System.out.println("接口初始化");
        }
    };

    public static final int num1 = 1;
    public static final int num2 = new Random().nextInt(10);
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Test1.num1); // 会执行初始化
        System.out.println(Test1.num2); // 不会执行初始化
        System.out.println(Test1.num3); // 会执行初始化
        
        System.out.println(Test2.num1); // 不会执行初始化
        System.out.println(Test2.num2); // 会执行初始化
    }
}

当使用反射加载某个类时。

public class Test {
    public static void main(String[] args) {
        Class clazz = Class.forName("com.example.Test");
    }
}

当初始化子类时，如果发现其存在父类，则需要先对其父类进行初始化。

public class Father{
    static {
        System.out.println("父类初始化");
    }
}

public class Son extends Father{
    static {
        System.out.println("子类初始化");
    }

    public static int num = 1;
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Son.num);
    }
}

💡【注意】： 在初始化一个类时，并不会先初始化它所实现的接口。在初始化一个接口时，并不会先初始化它的父接口。

如果一个类实现了某个接口，而这个接口中定义了default方法，那么在初始化该类之前，需要对这个接口进行初始化。

public interface ExampleInterface{
    public static final Thread t = new Thread(){
        {
            System.out.println("接口初始化");
        }
    };
    
    public default void method(){
        
    }
}

public class ExampleClass implements ExampleInterface{
    static {
        System.out.println("类初始化");
    }

    public static int num = 1;
}

public class Test {
    public static void main(String[] args) {
        System.out.println(ExampleClass.num);
    }
}

当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先初始化这个主类。
当初次调用MethodHandle实例时，会初始化该MethodHandle指向的方法所在的类。

被动使用

对于类的被动使用，不会进行类的初始化，被动使用的情况如下：

当访问一个静态字段时，只有真正声明这个字段的类才会被初始化。也就是当通过子类去调用父类的静态字段时，只会导致父类进行初始化，并不会导致子类初始化。

public class Father{
    static {
        System.out.println("父类初始化");
    }
    
    public static int num = 1;
}

public class Son extends Father{
    static {
        System.out.println("子类初始化");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Son.num);
    }
}

当创建关于类的数组时，不会导致类的初始化。

public class Example{
    static {
        System.out.println("类初始化");
    }
}

public class Test {
    public static void main(String[] args) {
        Example[] examples = new Example[10];
    }
}

调用常量不会引发类或接口的初始化。

public class Example{
    static {
        System.out.println("类初始化");
    }
    
    public static final int NUM = 1;
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Example.NUM);
    }
}

调用ClassLoader类的loadClass方法去加载一个类，不会导致类的初始化。

public class Test {
  public static void main(String[] args) {
       Class clazz = ClassLoader.getSystemClassLoader()
           				.loadClass("com.example.Person");
  }
}

二、类的使用阶段

任何一个类在使用之前都必须经历过完整的加载、链接和初始化这3个步骤，一旦这个类被加载初始化后，便可由开发者使用了。

三、类的卸载阶段

1.类、类加载器、类的实例之间的关系

在类加载器的内部实现中，会用一个集合来存放它所加载类的所有引用。我们通过某个类加载器可以知道它加载了哪些类，我们也可以通过某个Class对象获取它的类加载器，所以类和类加载器之间是双向关联的关系。
通过某个类实例对象中的getClass方法可以获得该实例属于哪个Class类。

2.类的生命周期

当一个类被加载、链接和初始化之后，它的生命周期就开始了。
当一个类的Class对象不再被引用，那么该类在方法区内的数据也会被清除，它的生命周期就结束了。

3.类的卸载

一个类想要被卸载，则需要同时满足下面的条件：
- 该类所有的实例以及派生子类的实例都已经被回收
- 该类对应的Class对象没有被任何地方引用
- 加载该类的类加载器已经被回收
启动类加载器加载的类在整个运行期间是不可能被卸载的。
系统类加载器和扩展类加载器加载的类在运行期间也不太可能被卸载，因为它们加载的类的实例基本上在整个运行期间总能直接或者间接的访问的到。
开发者自定义的类加载器加载的类只有在很简单的上下文环境中才能被卸载，而且一般还要强制调用虚拟机的垃圾收集功能才可以做到。
由此可以看出，一个已经加载的类被卸载的几率很小，而且被卸载的时间是不确定的。

举例

👉就上图而言，如果想要卸载Sample类，我们需要将图片左侧的三个引用变量都置空。

以上是关于JVM进阶之类加载过程详解(下篇)的主要内容，如果未能解决你的问题，请参考以下文章