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

Editor to share with you the sample analysis of class loading and class initialization order in java. I hope you will get something after reading this article. Let's discuss it together.

1. For static variables, static code blocks, variables, initialization code blocks, constructors, their order is: (static variables, static code blocks) > (variables, initialization code blocks) > constructors.

The existence of subclasses and parents is as follows:

(1) the code for the execution of a single class is as follows:

Public class InitOrderTest {

/ / static variable

Public static String staticField = "static variable"; / / variable public String field = "variable"; / / static initialization block static {System.out.println (staticField); System.out.println ("static initialization block");} / / initialization block {System.out.println (field); System.out.println ("initialization block");} / / constructor public InitOrderTest () {System.out.println ("constructor") } public static void main (String [] args) {new InitOrderTest ();}

}

The output is as follows:

(2) the situation for inheritance is as follows:

Class Parent {

/ / static variable

Public static String p_StaticField = "parent class-static variable"

Protected int i = 1

Protected int j = 8

/ / variable

Public String p_Field = "parent class-variable"

/ / static initialization block static {System.out.println (p_StaticField); System.out.println ("parent class-static initialization block");} / / initialization block {System.out.println (p_Field); System.out.println ("parent class-initialization block") } / / Constructor public Parent () {System.out.println ("parent class-constructor"); System.out.println ("I =" + I + ", j =" + j); j = 9;}

}

Public class SubClass extends Parent {

/ / static variable public static String s_StaticField = "subclass-static variable"; / / variable public String s_Field = "subclass-variable"; / / static initialization block static {System.out.println (s_StaticField); System.out.println ("subclass-static initialization block");} / initialization block {System.out.println (s_Field) System.out.println ("subclass-initializer block");} / / constructor public SubClass () {System.out.println ("subclass-constructor"); System.out.println ("I =" + I + ", j =" + j);} / / program entry public static void main (String [] args) {new SubClass ();}

}

The output is as follows:

Now, the result is self-evident. Initialization of static variables and static initialization blocks for subclasses is completed before variables, initialization blocks, and constructors of the parent class are initialized.

Static variables, static initialization blocks, variables, initialization blocks initialize the order depending on the order in which they appear in the class.

Execution process analysis

(1) access SubClass.main (), (this is a static method), and the loader will find the compiled code for the SubClass class (that is, the SubClass.class file) for you. During the loading process, the loader notices that it has a base class (that is, what extends means), so it loads the base class again. Whether you create a base class object or not, this process will happen. If the base class has a base class, the second base class is also loaded, and so on.

(2) perform static initialization of the root class, then static initialization of the next derived class, and so on. This order is important because the "static initialization" of a derived class may depend on the correct initialization of the base class members.

(3) when all the necessary classes have been loaded, start executing the body of the main () method and create the object with new SubClass ().

(4) if the class SubClass has a parent class, the constructor of the parent class is called, and you can use super to specify which constructor to call (that is, the first thing the Beetle () constructor does).

The construction process and construction order of the base class are the same as those of the derived class. First, the variables in the base class are initialized in literal order, and then the rest of the constructor of the base class is executed.

(5) initialize the subclass member data in the order they declare, and execute the rest of the subclass constructor.

Next, take a look at the class loading mechanism of java. Before analyzing the class loading mechanism, take a look at the following question:

Class Singleton {

Private static Singleton singleton = new Singleton ()

Public static int value1

Public static int value2 = 0

Private Singleton () {value1++; value2++;} public static Singleton getInstance () {return singleton;}

}

Class Singleton2 {

Public static int value1

Public static int value2 = 0

Private static Singleton2 singleton2 = new Singleton2 ()

Private Singleton2 () {value1++; value2++;} public static Singleton2 getInstance2 () {return singleton2;}

}

Public class TestClassLoader {

Public static void main (String [] args) {

Singleton singleton = Singleton.getInstance ()

System.out.println ("Singleton1 value1:" + singleton.value1)

System.out.println ("Singleton1 value2:" + singleton.value2)

Singleton2 singleton2 = Singleton2.getInstance2 (); System.out.println ("Singleton2 value1:" + singleton2.value1); System.out.println ("Singleton2 value2:" + singleton2.value2);}

}

The output is as follows:

Jvm class loading is divided into five processes: load, verify, prepare, parse, initialize, use, and unload, as follows:

Let's take a look at the specific actions of the five processes of loading, verification, preparation, parsing, and initialization.

1.1 loading

Loading is mainly about .class files (not necessarily .class). It can be a ZIP packet, which is obtained from the network). The binary byte stream is read into the JVM.

During the load phase, JVM needs to accomplish three things:

1) obtain the binary byte stream of the class through the fully qualified name of the class

2) transform the static storage structure represented by the byte stream into the run-time data structure of the method area

3) generate a java.lang.Class object of this class in memory as the access entry for all kinds of data of this class in the method area.

1.2 connection

1.2.1 Verification

Validation is the first step in the connection phase, mainly ensuring that the loaded byte stream conforms to the JVM specification.

The verification phase completes the following four stages of inspection:

1) File format verification

2) metadata validation (whether it conforms to Java language specification)

3) bytecode verification (make sure that the program semantics is legal and logical)

4) symbol reference verification (ensure that the next step of parsing can be performed normally)

1.2.2 preparation

Preparation is the second step in the connection phase, mainly allocating memory for static variables in the method area and setting default initial values.

1.2.3 parsing

Parsing is the third step in the connection phase, which is the process by which the virtual machine replaces symbolic references in the constant pool with direct references.

1.3 initialization

The initialization phase is the last step of the class loading process, which mainly assigns values to the class variables actively according to the assignment statements in the program.

Note:

1) when there is a parent class and the parent class is initialized, initialize the parent class first

2) then carry on the subclass initialization statement.

When do you need to initialize the class?

1) when instantiating an object using the new class

2) when reading or setting class static fields (except for final-decorated fields, except static final for static fields that are placed in the constant pool at compiler time)

3) when calling class static methods

4) when a reflection call is made to a class using reflection Class.forName ("xxxx"), the class needs to initialize

5) when initializing a class, there is a parent class, initialize the parent class first (Note: 1. With the exception of the interface, the parent interface will not be initialized until it is called. The subclass refers to the static field of the parent class and only initializes the parent class)

6) the class marked as the startup class (that is, the class that contains the main () method) should be initialized

7) when using JDK1.7 's dynamic language support, if the method handle of REF_getStatic, REF_putStatic, and REF_invokeStatic of a java.invoke.MethodHandle instance is parsed, and the corresponding class of this method handle has not been initialized, its initialization needs to be triggered first.

The above situation is called active reference to a class, and there are and as long as the above cases need to initialize the class.

Go back and analyze the initial interview questions:

Singleton output: 1 0

Reason:

1 first execute Singleton singleton = Singleton.getInstance () in main

Loading of class 2: loading class Singleton

Three types of verification

Type 4 preparation: allocate memory for static variables and set default values. Here, set the default value 0 for singleton (reference type) to null,value1,value2 (basic data type)

Initialization of type 5 (modified according to the assignment statement):

Execute private static Singleton singleton = new Singleton ()

Constructor that executes Singleton: value1++;value2++; at this time value1,value2 is equal to 1

Execution

Public static int value1

Public static int value2 = 0

At this time value1=1,value2=0

Singleton2 output: 1 1

Reason:

1 first execute Singleton2 singleton2 = Singleton2.getInstance2 () in main

Loading of class 2: loading class Singleton2

Three types of verification

Type 4 preparation: allocate memory for static variables and set default values. Here, the default value for value1,value2 (basic data type) is set to 0meme singleton 2 (reference type) to null

Initialization of type 5 (modified according to the assignment statement):

Execution

Public static int value2 = 0

At this point, value2=0 (value1 unchanged, still 0)

Execution

Private static Singleton singleton = new Singleton ()

Constructor that executes Singleton2: value1++;value2++

At this time, the value1,value2 is equal to 1, which is the final result.

The hierarchical relationship between class loaders is as follows:

This hierarchical relationship between class loaders is called the parent delegation model.

The parent delegation model requires that all classloaders, except for the top-level startup class loader (Bootstrap ClassLoader), have their own parent class loaders. The parent-child relationship between class loaders here is generally implemented not by inheritance, but by composition.

The working process of the parent delegation model

If a class accepts a class load request, it does not load the request himself, but delegates the class load request to the parent class loader, which is passed layer by layer until it reaches the startup class loader (Bootstrap ClassLoader).

Only if the parent loader cannot load the request will the child loader try to load it itself.

Code implementation of Parental delegation Model

The code implementation of the parent delegation model focuses on the loadClass () method of java.lang.ClassLoader.

1) first check whether the class is loaded. If not, call the loadClass () method of the parent class loader.

2) if the parent class loader is empty, the startup class loader is used as the parent loader by default

3) if the parent class fails to load, after throwing a ClassNotFoundException exception, call your own findClass () method.

The loadClass source code is as follows:

Destroy the parental delegation model

The parent delegation model solves the problem of the unity of the basic classes loaded by each class loader. That is, the more basic classes are loaded by the higher-level loaders.

What if the user code needs to be called back in the loaded base class and the top-level class loader does not recognize the user code? At this point, it is necessary to destroy the parental delegation model.

Here are two examples to illustrate the process of breaking the parental delegation model.

JNDI destroys the parental delegation model

JNDI is a standard Java service, and its code is loaded by the startup class loader. But JNDI needs to call back code implemented by independent vendors, and the class loader does not recognize these callback codes (SPI).

To solve this problem, a thread context class loader is introduced. It can be set through Thread.setContextClassLoader ().

The thread context class loader is used to load the required SPI code, that is, the parent class loader requests the child class loader to complete the class loading process, which destroys the parent delegation model.

Spring destroys the parental delegation model

Spring organizes and manages user programs, while user programs are generally placed in the WEB-INF directory and loaded by WebAppClassLoader class loaders, while Spring is loaded by Common class loaders or Shared class loaders.

So how does Spring access user programs under WEB-INF?

Use the thread context class loader. The classLoader used by Spring to load the class is obtained through Thread.currentThread (). GetContextClassLoader (). When a thread is created, an AppClassLoader classloader (corresponding to the WebAppclassLoader classloader in Tomcat) is created by default: setContextClassLoader (AppClassLoader).

Use this to load the user program. That is, any thread can get the WebAppclassLoader through getContextClassLoader ().

After reading this article, I believe you have a certain understanding of "sample analysis of class loading and class initialization order in java". If you want to know more about it, welcome to follow the industry information channel, thank you for reading!

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.