Class initialization mechanism of JVM

When you are in Java In the program new Object time , Have you considered JVM How to put static bytecode （byte code） To run time objects , The question seems simple , But clear students believe that there will not be too many , This article first introduces JVM Class initialization mechanism , And then give several error prone examples to analyze , Help you understand this knowledge better .

Loading, Linking, and Initialization

JVM Converting bytecode into runtime objects is divided into three stages , Namely ：loading 、Linking、initialization.

These three processes are introduced below ：

Loading

Loading The main task of the process is to ClassLoader complete . The process includes three things ：

1. According to the full name of the class , Generate a binary bytecode to represent the class
2. Parse the binary bytecode into the data structure corresponding to the method area
3. Finally, we generate a Class Object to represent the class

JVM In addition to the top Boostrap ClassLoader Yes, it is C/C++ Out of implementation , The other class loaders are made up of Java Realization , We can use getClassLoader Method to get the class loader of the current class ：

public class ClassLoaderDemo {
    public static void main(String[] args) {
        System.out.println(ClassLoaderDemo.class.getClassLoader());
    }
}

# [email protected]
# AppClassLoader  It's the one in the picture above  System Class Loader

Copy

Besides , We're starting java Pass in -verbose:class To see which classes are loaded .

java -verbose:class ClassLoaderDemo

[Opened /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Object from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.io.Serializable from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Comparable from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.CharSequence from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]

....
....

[Loaded java.security.BasicPermissionCollection from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded ClassLoaderDemo from file:/Users/liujiacai/codes/IdeaProjects/mysql-test/target/classes/]
[Loaded sun.launcher.LauncherHelper$FXHelper from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Class$MethodArray from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Void from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[email protected]
[Loaded java.lang.Shutdown from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Shutdown$Lock from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]

Copy

Linking

Verification

Verification The main purpose is to ensure that the class conforms to Java Grammatical norms , Make sure it doesn't affect JVM Operation of . Including but not limited to the following ：

• bytecode The integrity of （integrity）
• Check final Class is not inherited ,final Method is not overridden
• Make sure there are no incompatible method signatures

Preparation

In a class that has been load And through verification after , Just enter preparation Stage . At this stage ,JVM It allocates memory space for the member variables of the class and gives the default initial value , It's important to note that no code is executed at this stage , But only based on Variable type Determine initial value . Without default initialization , The value of the allocated space is random , It's kind of c The problem of wild pointer in language .

Type    Initial Value
int    0
long    0L
short    (short) 0
char    '\u0000'
byte    (byte) 0
boolean    false
reference    null
float    0.0f
double    0.0d

Copy

At this stage ,JVM It may also allocate memory for data structures that help improve program performance , A common one is called method table Data structure of , It contains methods that point to all classes （ It also includes methods that are inherited from the parent class ） The pointer to , In this way, when you call the parent class method again, you don't need to search .

Resolution

Resolution The main work of the stage is to confirm the class 、 Interface 、 Properties and methods in class run-time constant pool The location of , And quote these symbols （symbolic references） Replace with direct reference （direct references）.

locating classes, interfaces, fields, and methods referenced symbolically from a type’s constant pool, and replacing those symbolic references with direct references.

This process is not necessary , It can also happen the first time a symbol reference is used .

Initialization

After the above load、link after , for the first time Active call The last step in a class is Initialization, This process will be initialized according to the code writing order , This phase is going to actually execute the code , Attention includes ： Code block （static And static）、 Constructors 、 Variable explicit assignment . If a class has a parent , Will execute the parent class first initialization Stage , And then in the implementation of their own .

There are two key words in the above passage ： for the first time And Active call . for the first time It means that the initialization process will only occur the first time , I don't need it anymore , It can be understood as each class There is and only once Opportunity to initialize . So what is Active call Well ？ JVM The following six cases are specified as Active call , The rest are Passive call ：

1. An instance of a class is created （new operation 、 Reflection 、cloning, Deserialization ）
2. The calling class static Method
3. Use or pair classes / Interface static Property is assigned （ This does not include final And constant expressions determined at compile time ）
4. When calling API Some reflection methods in
5. Subclass is initialized
6. Be set to JVM The startup class at startup （ have main Class of method ）

An example will be given later in this article to illustrate Active call Of Passive call difference .

At this stage , The order in which the code is executed follows two principles ：

1. Yes static Initialize first static, Then right and wrong static Of
2. Explicitly initialize , Building block initialization , Finally, the constructor is initialized

Example

Property assignment in different periods

class Singleton {

    private static Singleton mInstance = new Singleton();//  Location 1
    public static int counter1;
    public static int counter2 = 0;

//    private static Singleton mInstance = new Singleton();//  Location 2

    private Singleton() {
        counter1++;
        counter2++;
    }

    public static Singleton getInstantce() {
        return mInstance;
    }
}

public class InitDemo {

    public static void main(String[] args) {

        Singleton singleton = Singleton.getInstantce();
        System.out.println("counter1: " + singleton.counter1);
        System.out.println("counter2: " + singleton.counter2);
    }
}

Copy

When mInstance In position 1 when , Print out

counter1: 1
counter2: 0

Copy

When mInstance In position 2 when , Print out

counter1: 1
counter2: 1

Copy

Singleton The three attributes in Preparation Phases are assigned default values depending on the type , stay Initialization The stage will assign again based on the expression that shows the assignment （ Top down in order ）. According to these two points , It's not hard to understand the above results .

Active call vs. Passive call

class NewParent {

    static int hoursOfSleep = (int) (Math.random() * 3.0);

    static {
        System.out.println("NewParent was initialized.");
    }
}

class NewbornBaby extends NewParent {

    static int hoursOfCrying = 6 + (int) (Math.random() * 2.0);

    static {
        System.out.println("NewbornBaby was initialized.");
    }
}

public class ActiveUsageDemo {

    // Invoking main() is an active use of ActiveUsageDemo
    public static void main(String[] args) {

        // Using hoursOfSleep is an active use of NewParent,
        // but a passive use of NewbornBaby
        System.out.println(NewbornBaby.hoursOfSleep);
    }

    static {
        System.out.println("ActiveUsageDemo was initialized.");
    }
}

Copy

The program above finally outputs ：

ActiveUsageDemo was initialized.
NewParent was initialized.
1

Copy

The reason there is no output NewbornBaby was initialized. It's because I didn't take the initiative to call NewbornBaby, If you change the printed content to NewbornBaby.hoursOfCrying So this is the active call NewbornBaby 了 , The corresponding statement will also be printed out .

The first active call will initialize

public class Alibaba {

    public static int k = 0;
    public static Alibaba t1 = new Alibaba("t1");
    public static Alibaba t2 = new Alibaba("t2");
    public static int i = print("i");
    public static int n = 99;
    private int a = 0;
    public int j = print("j");
    {
        print(" Tectonic block ");
    }
    static {
        print(" A static block ");
    }

    public Alibaba(String str) {
        System.out.println((++k) + ":" + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;
    }

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

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

Copy

The above example is Alibaba in 14 Additional questions of school enrollment in , I saw this question at the time , I feel that I have no chance with ALI . Embarrassed

1:j   i=0    n=0
2: Tectonic block    i=1    n=1
3:t1   i=2    n=2
4:j   i=3    n=3
5: Tectonic block    i=4    n=4
6:t2   i=5    n=5
7:i   i=6    n=6
8: A static block    i=7    n=99
9:j   i=8    n=100
10: Tectonic block    i=9    n=101
11:init   i=10    n=102

Copy

Above is the output of the program , Next, I'll make a line by line analysis .

because Alibaba yes JVM The start of class , It belongs to active call , So it's going to be like this loading、linking、initialization Three processes .

after loading And linking After the stage , All properties have default values , And then into the final initialization Stage .

stay initialization Stage , First pair static Attribute assignment , And then in Africa static Of .k The first explicit assignment is 0 .

Next is t1 attribute , Because at this moment Alibaba This class is already in initialization Stage ,static Variables don't need to be initialized again , So ignore static Assignment of a property , Only right and wrong static The property of , All that has a beginning ：

Then on t2 Assign a value , Process and t1 identical

Then came static Of i And n：

Up to now , be-all static The member variable of has been assigned , And here we are static Code block

thus , be-all static Partial assignment complete , Next, right and wrong static Of j

All properties are assigned , Finally, building blocks and constructors

Pass by here 9 Step ,Alibaba The initialization of this class is complete . One of the things that's more likely to go wrong is 3 Step , Think it will initialize again static Variables or code blocks . And it's not really necessary , Otherwise, there will be multiple initializations .

I hope you can think more about the results of this example , Deepen the understanding of these three processes .

summary

After the last three examples , I'm sure you're right JVM Have a deeper understanding of the class loading mechanism , If you still have questions , Welcome to pay attention to the discussion .

Reference resources

• Java Virtual Machine Specification Chapter 5
• Chapter 7 of Inside the Java Virtual Machine
• JVM Internals
• What kind of method is Constructor, static or non static?
• Understanding the Java ClassLoader