An in-depth explanation of the JVM class loading mechanism: from loading to unloading

The class loading mechanism includes three steps: loading, linking and initialization. Loading: Read the class file binary data into memory and create a bytecode description object. Linking: Validates, prepares, and parses bytecode description objects and associates them with other classes. Initialization: Execute static initialization program, assign static variables, and establish inheritance relationships. When the class is no longer referenced, the JVM performs reachability analysis to mark the class as recyclable, and the garbage collector reclaims the memory of the marked class, but the static variables remain in memory.

In-depth explanation of JVM class loading mechanism: from loading to unloading

Foreword

Understanding the Java Virtual Machine (JVM )'s class loading mechanism is crucial to mastering Java development. This article will take an in-depth look at how the JVM loads, links, and unloads classes, and illustrates this mechanism through practical examples.

Class loading process

The class loading process includes the following three steps:

1. Loading: class file The binary data is read into the memory and a bytecode description object representing the class is created.
2. Linking: Verify, prepare and parse the bytecode description object and relate it to other classes in the system.
3. Initialization: Execute the static initialization program of the class, assign values ​​to static variables, and establish the inheritance relationship between the class and subclasses.

Class unloading process

When a class is no longer referenced, the JVM will perform the following steps to unload it:

1. Mark as recyclable: The JVM marks classes that are no longer referenced through reachability analysis.
2. Garbage Collection: The garbage collector reclaims the memory space of classes marked as recyclable.

Practical case

Sample code:

public class MyClass {

    private static int staticVar = 10;
    private int instanceVar = 20;

    public static void main(String[] args) {
        MyClass obj = new MyClass();
        System.out.println(staticVar);  // 输出 10
        System.out.println(obj.instanceVar);  // 输出 20
    }

}

Class loading analysis:

• Loading: When MyClass is instantiated, its class file is loaded into memory and a bytecode description object is created.
• Link: The bytecode description object is verified, prepared and parsed, associated to the System class.
• Initialization: Static variable staticVar is assigned a value of 10, and the class establishes an inheritance relationship with its subclasses.

Class unloading analysis:

When the obj variable goes out of scope and is garbage collected:

• Marked as recyclable: MyClass The object is marked as recyclable because artık is no longer referenced.
• Garbage collection: The garbage collector reclaims the memory space of the MyClass object.
• Static variable retention: Even if the class has been unloaded, the static variable staticVar still remains in memory because it is maintained by the class loader.

The above is the detailed content of An in-depth explanation of the JVM class loading mechanism: from loading to unloading. For more information, please follow other related articles on the PHP Chinese website!