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

Java Class class loading process is how, many novices are not very clear about this, in order to help you solve this problem, the following editor will explain in detail for you, people with this need can come to learn, I hope you can gain something.

The java virtual machine loads the class file as follows:

Conditions for type 1 loading

Class files are loaded only when they must be used, and java virtual machines do not load class types unconditionally. The java virtual machine states that a class or interface must be initialized before it is used for the first time. The term "use" here refers to active use, and there are only the following situations:

When creating an instance of a class, such as using the new keyword or reflection, cloning, deserialization.

The bytecode invokestatic instruction is used when calling the static method of the class.

When using static fields of a class or interface (except for final constants), such as using getstatic or putstatic instructions.

When using the methods in the java.lang.reflect package to reflect the methods of the class.

When initializing a subclass, the parent class is required to be initialized first.

As the class that starts the virtual machine, it contains the main () method.

Example 1: active use of public class Parent {static {System.out.println ("Parent init");} public static int v = 100;} public class Child extends Parent {static {System.out.println ("Child init");}} public class Demo01 {public static void main (String [] args) {Child c = new Child ();}}

The above code declares three classes: Parent, Child, and Demo01,Child are subclasses of Parent. If Parent is initialized, as can be seen from the static statement block in the code, "Parent Init" will be printed. If Child is initialized, "Child Init" will be printed, Demo01 will be executed, and the result will be run:

Parent initChild init

From this, the system loads the Parent class first, then the Child class.

Example 2: passive use of public class Parent {static {System.out.println ("Parent init");} public static int v = 100;} public class Child extends Parent {static {System.out.println ("Child init");}} public class Demo02 {public static void main (String [] args) {System.out.println (Child.v);}}

Looking at the above code, there is a static variable v in Parent, and in Demo02, you use its subclass Child to call variables in the parent class. Run the above code, and the output is as follows:

Parent init100

As you can see, although the subclass object is accessed directly in Demo02, the Child subclass is not initialized, only the Parent parent class is initialized. It can be seen that when using a field, only the class that defines the field directly will be initialized.

Note: although the Child class has not been initialized, the Child class has been loaded by the system at this time, but has not entered the initialization phase.

Run this code with the-XX:+TraceClassLoading parameter, and you will get the following log (delete part of the output):

Oaded java.net.Inet6Address from / Library/Java/JavaVirtualMachines/jdk1.8.0_201.jdk/Contents/Home/jre/lib/rt.jar] [Loaded java.net.Inet6Address$Inet6AddressHolder from / Library/Java/JavaVirtualMachines/jdk1.8.0_201.jdk/Contents/Home/jre/lib/rt.jar] [Loaded jvm.chapter10.Parent from file:/Users/chengyan/IdeaProjects/myproject/DataStructuresAndAlgorithms/out/production/DataStructuresAndAlgorithms/] [Loaded jvm.chapter10.Child from file:/Users/chengyan/IdeaProjects/myproject/ DataStructuresAndAlgorithms/out/production/DataStructuresAndAlgorithms/] Parent init1002 load class

Loading a class is in the first stage of class loading. When loading a class, the java virtual machine must do the following:

Get the binary data source of the class through its full name

Parse the binary data flow of the class into the data structure in the method area

Create an instance of the java.lang.Class class that represents the type

For binary data streams of classes, virtual machines may generate or obtain binary data streams through a variety of ways, such as class files, or archive packets such as jar, zip, etc., or they can also be loaded through the network.

After getting the binary data of the class, the java virtual machine processes the data and eventually becomes an instance provided by the java.lang.Class class.

3 validation class

When the class is loaded into the system, the continuous operation begins, and validation is the first step in the continuous operation. Its purpose is to keep the loaded bytecode legal, reasonable, and in accordance with the specification. The steps of verification are complicated, and there are many projects to be verified. Generally speaking, the java virtual machine needs to be checked as follows:

4 preparation

When a class validation is sad, the virtual machine enters the preparation phase. At this stage, the virtual machine allocates the appropriate memory space for the class and sets the initial value. The initial values of variable defaults for each type of java virtual machine are as follows:

Type default initial value int0long0Lshort (short) 0char\ u0000booleanfalsereferencenullfloat0fdouble0d

Note: java does not support boolean types. For boolean types, the internal implementation is actually int types. Since the default value of int type is 0, the default value of the corresponding boolean type is false.

If the class has a constant field (final-decorated field), the constant field will also be assigned the correct value in the preparation phase, which belongs to the behavior of the java virtual machine and belongs to the initialization of the variable.

5 Analytic class

The preparation phase is followed by the parsing phase. The job of the parsing phase is to convert symbolic references to classes, interfaces, fields, and methods into direct references.

Symbolic references are literal references that have nothing to do with the internal data structure of the virtual machine and memory layout. In Class class files, there are a large number of symbolic references, but at run time, only symbolic references are not enough, the system needs to be clear about the location of variables, methods, and so on. Take the method as an example, the java virtual machine prepares a method table for each class and lists all its methods in the table. When you need to call a method of a class, you can call it directly as long as you know the offset of the method in the method table. Through the parsing operation, the symbolic reference can be transformed into the location of the directory method in the method table of the class, so that the method is called successfully.

To sum up, the so-called parsing is to convert a symbolic reference into a direct reference, that is, to get the pointer or offset of a class or field or method in memory.

6 initialization

Class initialization is the last stage of class loading, and if there is no problem with the previous steps, it means that the class can be successfully loaded into the system. At this point, the class starts executing the java bytecode. An important task in the initialization phase is to execute the initialization methods of the class. The method is automatically generated by the compiler and is generated by the assignment statement of the static member and the static statement block.

It is worth mentioning that for methods, that is, class initialization, the virtual machine internally ensures security in its multithreaded environment. That is, when multiple threads try to initialize the same class, only one thread can enter the method (when the class is needed, the virtual machine will directly return the information it has prepared).

Because methods are thread-safe with locks, class initialization in a multithreaded environment may cause deadlocks, and such deadlocks are difficult to find because they do not seem to have available lock information.

The following code shows that a deadlock thread is generated during class initialization:

Package jvm.chapter10;class StaticA {static {Thread.sleep (1000);} catch (Exception e) {} try {Class.forName ("jvm.chapter10.StaticB");} catch (ClassNotFoundException e) {} System.out.println ("StaticA init OK!") }} class StaticB {static {try {Thread.sleep (1000);} catch (Exception e) {} try {Class.forName ("jvm.chapter10.StaticA");} catch (Exception e) {} System.out.println ("StaticB init OK");}} public class Demo03 extends Thread {private char flag Public Demo03 (char flag) {this.flag = flag;} @ Override public void run () {try {Class.forName ("jvm.chapter10.Static" + flag);} catch (Exception e) {} System.out.println (getName () + "over");} public static void main (String [] args) throws Exception {Demo03 loadA = new Demo03 ('A') Demo03 loadB = new Demo03 ('B'); loadA.start (); loadB.start (); loadA.join (); loadB.join ();}}

The above code consists of three classes: StaticA, StaticB and Demo03. Two threads are created in Demo03, thread An attempts to initialize StaticA, thread B attempts to initialize StaticB, during the initialization of StaticA, it attempts to initialize StaticB, and also initializes StaticA during the initialization of StaticB, which leads to deadlock.

The following information can be obtained from the thread stack dump:

"Thread-1" # 12 prio=5 os_prio=31 tid=0x00007f9dd4853000 nid=0x5703 in Object.wait () [0x0000700004797000] java.lang.Thread.State: RUNNABLE at java.lang.Class.forName0 (Native Method) at java.lang.Class.forName (Class.java:264) at jvm.chapter10.StaticB. (Demo03.java:33) at java.lang.Class.forName0 (Native Method) at java.lang.Class.forName (Class.java:264 ) at jvm.chapter10.Demo03.run (Demo03.java:52) Locked ownable synchronizers:-None "Thread-0" # 11 prio=5 os_prio=31 tid=0x00007f9dd4801800 nid=0xa803 in Object.wait () [0x0000700004694000] java.lang.Thread.State: RUNNABLE at java.lang.Class.forName0 (Native Method) at java.lang.Class.forName (Class.java:264) at jvm.chapter10.StaticA. (Demo03.java:17) At java.lang.Class.forName0 (Native Method) at java.lang.Class.forName (Class.java:264) at jvm.chapter10.Demo03.run (Demo03.java:52) Locked ownable synchronizers:-None

In this case, the system does not give enough information to determine deadlocks, but deadlocks do exist, and we need to be extra careful about the deadlock problems caused by class initialization.

Is it helpful for you to read the above content? If you want to know more about the relevant knowledge or read more related articles, please follow the industry information channel, thank you for your support.

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.