Shulou(Shulou.com)06/03 Report--

This article focuses on "how to understand the class loading mechanism". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to understand the class loading mechanism.

How on earth did the class we wrote be loaded into the virtual machine after compilation? What magical actions did the virtual machine do? This article can take the reader to explore the class loading mechanism. Let the class load the main tasks of each stage first, which is used to give the reader a general impression of the experience. It doesn't matter if you can't remember it now.

Now we only need to remember three nouns, load-> connect-- > initialize, remember, we are going to start fantasy rafting!

1. Loading

I think it is better to use loading here. First, it can avoid confusion with "loading" in the process of class loading. Second, loading reflects the word "loading", just moving goods from one place to another. Loading here, however, includes a series of processes such as moving goods, handling goods, and so on.

In the loading phase, the binary data of the .class bytecode file is read into memory, and then the data is translated into class metadata, including method code, variable name, method name, access rights and return values, and then the metadata is stored in the method area. Finally, a Class object is created in the heap to encapsulate the data structure of the class in the method area, so we can access the metadata in the method area indirectly by accessing this Class object.

After Java7 and Java8, the method area has different implementations, and for more information, please refer to my other blog, spirituality-Why replace permanent generations with metaspaces?

To sum up, the subprocess of loading is:

The .class file is read into memory-- > metadata is put into the method area-- > Class objects are put into the heap

Finally, we visit the Class object to get the structure of the class in the method area.

two。 Connect

Connection also includes verification, preparation and initialization.

2.1 Verification

Verify the correctness and security of the loaded class, see whether the class file is correct, whether it will cause security problems to the virtual machine, etc., mainly to verify the file format, metadata, bytecode and compliance references.

2.1.1 verify the file format

2.1.1.1 verify the file type

Each file has a specific type, type identification field exists at the beginning of the file, using hexadecimal representation, type identification field is called magic number, class file magic number is 0xCAFEBABY, about the origin of this magic number is also very interesting, you can see this article class document magic number CAFEBABE origin.

2.1.1.2 verify the major and minor version number

Check to see if the major and minor version numbers are within the scope of the current jvm processing, and the storage location of the major and minor version numbers is immediately after the magic number.

2.1.1.3 verify constant pool

The constant pool is the most complex part of the class file, and the verification of the constant pool is mainly to verify whether there are unsupported types in the constant pool.

For example, there is the following code for a short answer:

Public class Main {public static void main (String [] args) {int astat1; int bread2; int cymafib;}}

Under the path of the class, compile with javac Main.java, and then use javap-v Main to output the following information:

The red mark above is where the constant pool is stored in the class file.

2.1.2 validating metadata

The main purpose of this paper is to semantically analyze the information described by bytecode to ensure that the information described meets the requirements of java language specifications, such as verifying whether the class has a parent class, whether the field methods in the class conflict with the parent class, and so on.

2.1.3 verify bytecode

This is the most complex stage of the whole verification process, mainly through the analysis of data flow and control flow to determine that the program semantics is legal and logical.

2.1.4 verify symbol references

It is the last stage of validation, when the virtual machine converts a symbolic reference to a direct reference. The main purpose is to verify the information other than the class itself. The goal is to ensure that the parsing action can be completed.

For the entire class loading mechanism, the verification phase is a very important but not necessary stage, if our code can ensure that there is no problem, then there is no need to verify, after all, verification takes a certain amount of time, you can use-Xverfity:none to turn off most of the validation.

2.2 preparation

At this stage, the main task is to allocate memory for class variables (static variables) and initialize default values, because there is only one global copy of static variables and follows the class, so the allocated memory is actually allocated on the method area.

Here are three points to note:

(1) in the preparation phase, the virtual machine only allocates memory for static variables, and instance variables do not begin to allocate memory until the initialization phase. At this time, there is no instantiation of the class, not even an object, so there are no instance variables at this time.

(2) initialize the default value for the static variable. Note that it initializes the default value of the corresponding data type, not the custom value.

For example, it is written in the code that the value of a variable of custom int type is 1

Private static int axi1

However, after the preparation phase is complete, the value of an is only initialized to 0, not 1.

(3) static variables modified by final, if the value is small, are directly embedded in the bytecode after compilation. If the value is large, it is also put directly into the constant pool after compilation. Therefore, by the end of the preparation phase, static variables of type final already have user-defined values instead of default values.

2.3 Analysis

In the parsing phase, the main purpose is to convert symbolic references in the constant pool in class files into direct references.

The meaning of symbolic references:

Can be directly understood as a string, using this string to represent a target. Just as the blogger's name is SunAlwaysOnline, the SunAlwaysOnline string is a symbolic reference that represents the blogger, but I can't find myself directly by name right now.

The meaning of direct citation:

A direct reference is a pointer to a target that can be located by a direct reference. such as

Student s=new Student ()

We can navigate directly to the newly created instance of the Student object by referencing the variable s.

By converting a symbolic reference to a direct reference, you can convert a mundane string into a pointer to an object.

3. Initialization

Performing initialization is the process by which the virtual machine executes the class constructor () method, which is generated by the compiler automatically collecting all class variables in the class and merging static statement blocks. There may be multiple threads executing the () method of a class at the same time, and the virtual machine locks the method to ensure that only one thread can execute.

At this stage, class variables and class member variables are assigned user-defined values.

Of course, a class is not initialized multiple times, and only when the first active use of the class results in class initialization. Active use includes the following ways:

Use the new statement to create an object of the class to access the class static variable, or assign a value to the static variable to call the static method of the class to get the object instance through reflection. When a class with a public static void main (String [] args) method is initialized first, if the parent class has not been initialized, the parent class is initialized first, and then the class is initialized.

What happens when passive use occurs?

When accessing a static variable, only the class that actually declares the static variable is initialized. For example, referencing the static variable of the parent class through the subclass does not cause the subclass to initialize. Reference constants do not trigger initialization of this class (constants are embedded in bytecode or stored in the constant pool of the calling class at compile time) when the array is declared and created, the class initialization is not triggered. For example, Student array=new Student [2]

4. Initialization order of the class

Now you have the following code:

Class Father {public static int fatherA = 1; public static final int fatherB = 2; static {System.out.println ("static code block of parent class");} {System.out.println ("non-static code block of parent class");} Father () {System.out.println ("constructor of parent class") }} class Son extends Father {public static int sonA = 3; public static final int sonB = 4; static {System.out.println ("static code block of subclass");} {System.out.println ("non-static code block of subclass");} Son () {System.out.println ("constructor of subclass");}}

(1) instantiate subclasses in the Main method:

Public class Main {public static void main (String [] args) {Son son = new Son ();}}

First of all, it is certain that this is an active use, and the parent class is initialized before the subclass, so you get the following output:

It can be summarized here, and the order of program execution is as follows:

Static domain of parent class-> static domain of subclass-> non-static domain of parent class-> non-static domain of subclass-> constructor of parent class-> constructor of subclass

The static field here includes static variables and static code blocks, and the execution order of static variables and static code blocks is determined by the coding order.

The rule is that the static precedes the non-static, the parent precedes the child, and the construction method comes last. Yeah, recite it for me three times.

(2) output the sonA attribute of the subclass in the Mian method

Public class Main {public static void main (String [] args) {System.out.println (Son.sonA);}}

Here you just output the static property sonA of the subclass, so you need to initialize the subclass, but the parent class hasn't been initialized yet, so initialize the parent class first. In general, static code blocks assign values to static variables, so static attributes are called, and the virtual machine invokes the static code block before that. So, the output is as follows:

(3) the Main method outputs the fatherA attribute inherited by the subclass

Public class Main {public static void main (String [] args) {System.out.println (Son.fatherA);}}

A property that a subclass inherits from the parent class, so it is used passively. Only the initialization of the class where the static property actually exists, that is, only the parent class is initialized. Therefore, the output:

(4) declare and create an array of subclass types in the Main method

Public class Main {public static void main (String [] args) {Son [] sons=new Son [10];}}

Obviously, this is passive use and does not initialize the Son class. Therefore, there is no output.

(5) the Main method outputs variables whose subclasses are modified by static final.

Public class Main {public static void main (String [] args) {System.out.println (Son.sonB);}}

Obviously, the variable modified by static final, that is, a constant, is put into the constant pool of the class by the compiler, and there is no need to initialize the class. Therefore, only the value of sonB is output here, which is 4.

(6) use a static variable before declaration

Public class Main {static {c = 1;} public static int c;}

This kind of code can run, children, do you have a big question? But let me analyze it carefully.

First, in the preparation phase, memory is allocated for the static variable c, and then an initial value of 0 is assigned. When it comes to the initialization phase, the static field of the execution class, that is, the static code block executed here, already exists, and there is a default value of 0, so you can change the value of c.

However, if I only use c after canti1, such as:

Public class Main {static {c = 1; System.out.println (c);} public static int c;}

At this point, the compilation cannot pass, and the editor prompts Illegal forward reference, that is, an illegal forward reference. It seems that it can only write c, not read c. As we have analyzed before, there is this c in memory at this time, so why can't we read c?

Under normal circumstances, in order to use a variable, the variable needs to be declared first. Of course, java makes a concession that allows it not to be declared before use, but several conditions must be met, one of which is that the variable can only appear on the left side of the assignment expression, that is, cantilever 1 can, censor 2 can, and cantilever 1 cannot (cantilever 1, that is, c=c+1, violates the left-value agreement). Of course, if you use a fully qualified name here, that is, when you output Main.c, it works fine.

Some friends may still have big questions. Never mind, those who don't understand can refer to the following articles explaining illegal forward citations.

Illegal forward reference problem in java error reporting

Java compile-time prompt for illegal forward reference

Illegal forward Reference java issue

At this point, I believe you have a deeper understanding of "how to understand the class loading mechanism". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.