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

This article mainly explains "what is the class loader of JVM". Interested friends may wish to have a look at it. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn "what is the class loader of JVM"?

1. What is JVM?

Since we are learning the relevant theoretical knowledge about JVM, we certainly need to know what JVM is. JVM is the abbreviation of Java Virtual Machine (Java Virtual Machine). Now that we are talking about virtual machines, some people may ask what a virtual machine is. I put the relevant concepts of virtual machines here:

Virtual machine: a virtual computer, which is a piece of software; used to execute a series of computer instructions. Virtual machines can be divided into system virtual machines and program virtual machines.

System virtual machines: such as VMware, they are complete simulations of physical computers, providing a software platform that can run a complete operating system.

Program virtual machine: such as the Java virtual machine, which is specially designed to execute a single computer program. The instructions executed in the Java virtual machine are called Java bytecode instructions. (JVM runs on the operating system and has no direct interaction with the hardware.)

So by definition, we can know that JVM is a program virtual machine. So where is JVM? in fact, when we first learn Java, we must download the JDK installation package from the Internet according to the running environment of Java. After installation, there will be two folders under the installation path, one is called Jdk, the other is called jre, and the java virtual machine is in the folder of jre.

Existence is the reason for his existence, so what is the use of the existence of JVM? What does he do with it? Anyone who has studied JAVA knows that in order to run a java program, the Java source program (.java) must first be compiled into a platform-independent bytecode file (.class), and then interpreted as machine code to run. It is explained that this process is performed through the Java virtual machine (which can be understood in the following figure). The java virtual machine is here to interpret bytecode files, and explaining this process is actually a very complex process, so this is the topic we are going to talk about today.

two。 Class loading (classLoading)

Let's first take a look at the whole process of class loading. As you can see from the following figure, the life cycle of a class is divided into five phases: loading, connecting (including validation, preparation, and parsing), initialization, use (class instantiation), and unloading (garbage collection).

In the Java code, we all know that the loading, connection, and initialization of a class (which refers to the Class of the class itself, such as Interface,Enum) is completed while the program is running. Let's start with loading, connecting, and initializing classes.

Class loading: * the most common situation * is to load the Class file (that is, the bytecode file) of the existing class from disk into memory, place it in the method area of the runtime data area, and then create a java.lang.Class object in memory to encapsulate the data structure of the class in the method area.

Class connection (which is subdivided into three phases):

Verify: ensure the correctness of the loaded class

Prepare: allocate memory for static variables of a class (also known as class variables) and initialize them to the default value (for example, the default value of int is 0)

Parsing: converting symbolic references in a class to direct references

Initialization of the class: assign values to the static variables of the class (from top to bottom of the code)

Java programs use classes in two ways:

Active use

Passive use

All Java virtual machine implementations initialize each class or interface when it is "actively used" by a Java program, keeping in mind that the class is initialized only when it is used for the first time and actively.

If active use of its class or interface results in initialization (initialization at this time means loading and connecting (the three steps of connection, note that the connection at this time only completes the allocation of memory by static variables of the class, and initializes it to the default value) has been completed)

Here is a summary of 7 active uses:

Create an instance of the class

Access the static variable of a class or interface, or assign a value to it

Call the static method of the class

Reflection (such as class.forName ())

Initialize a subclass of a class

A class that is indicated as a startup class when the Java virtual machine starts

JDK1.7 begins to improve dynamic language support

Except for the above seven cases, other ways of using the Java class are seen as passive use of the class, which does not lead to class initialization.

3. Load connection initialization of class is explained in detail

In fact, we know that the final product of class loading is the Class object located in memory. The Class object encapsulates the data structure of the class in the method area, and provides Java programmers with an interface to access the data structure in the method area.

From the above summary, we know that the connection of a class actually enters the connection phase when the class is loaded. A connection is to merge the binary data of a class that has been read into memory into the running environment of the virtual machine. So what is the content of class validation?

Structure check of class files

Semantic check

Bytecode verification

Verification of binary compatibility

4. Class loader

Class loading is actually done by the class loader, and we can think of the class loader as a villain who helps JVM work. So what is the definition of classloader? here is a summary according to my personal understanding:

Class loader (classLoader): the class loader is used to load the class into the memory space of the Java virtual machine (the tool for loading the class, the class must be loaded by the class loader). Starting with the JDK1.2 version, the class loading process uses a parent delegate mechanism. This mechanism can better ensure the security of the Java platform. In this delegation mechanism, except for the root class loader that comes with the Java virtual machine (because the root class loader itself does not have a parent loader), all other class loaders have one and only one parent loader. When the Java program requests the loader loader1 to load the Sample class, loader1 first entrusts its parent loader to load the Sample class. If the parent loader can load the Sample class, the parent loader completes the loading task, otherwise the loader loader1 itself loads the Sample class.

There are two types of classloaders:

(1) the loader that comes with Java virtual machine

Root class loader (BootstrapClassLoader), also known as boot class loader

Extended class loader (ExtensionClassLoader)

System (application) class loader (SystemClassLoader or AppClassLoader)

(2) user-defined class loader

Subclasses of java.lang.ClassLoader (all user-defined class loaders should inherit the abstract class ClassLoader class)

Users can customize how the class is loaded.

The class loader does not need to wait for a class to be used actively for the first time before loading it

5. Detailed explanation of parent entrustment mechanism of class loader

In this section, let's take a closer look at the parent delegation mechanism of the classloader. Father delegation mechanism is also known as parent delegation mechanism (I personally understand that it should actually be called father delegation mechanism, because it is parent rather than parents in the source code): in father delegation mechanism, each loader forms a familiar structure according to the father-son relationship (logically, such as the following figure), except for starting the class loader, the rest of the class loader has and only one parent loader.

The following loaders appear to be inheritance relationships, but actually include relationships.

Let me give an example to look at the actual implementation of the father's entrustment mechanism:

For the execution process of the above figure, I need to explain in detail how the parent delegation mechanism of the class loader is executed: first of all, loader1 and loader2 are our custom loaders. Loader1 tries to load the Sample class. According to the parent delegation mechanism, it is not for loader1 to load the Sample class directly into the virtual machine. Instead, it transfers the loading task to the system class loader to complete. The system class loader transfers the loading task to the extension class loader, and then the extension class loader transfers it to the root class loader. Since the root class loader is already the top level of the class loader architecture, the root class loader will try to load the Sample class into the virtual machine (then the root class loader cannot load because it loads from several specific directories), since the root class loader cannot complete loading He will return the task to the extension class loader (similarly, it cannot be loaded in principle), and then let the system class loader load it (usually it can load successfully). Finally, the process is returned to loader1, which declares the class loading process to be over.

6. Several ways to obtain Class Loader

Now that we know the types of classloaders, we also need to know how to get the classloader and how to get the classloader. I've summarized four ways here:

First: get the ClassLoader of the current class:

Clazz.getClassLoder ()

The implementation is as follows:

Class clazz1 = Class.forName ("java.lang.String"); System.out.println (clazz1.getClassLoader ())

The second is to get the ClassLoader of the current thread context:

Thread.currentThread () .getContextClassLoader ()

The implementation is as follows:

ClassLoader contextClassLoader = Thread.currentThread () .getContextClassLoader (); System.out.println (contextClassLoader)

The third kind: get the system ClassLoader:

ClassLoader.getSystemClassLoader ()

Fourth: get the caller's ClassLoader

DriverManager.getCallerLoader ()

We also need to know that the array is not actually created by the classloader, but is automatically created by the jvm runtime when needed. For the array, its classloader is the same as the class loading of other element types. If the element type is a primitive type, the array does not have a classloader.

The ClassLoader class itself is parallel capable by default. If the subclass wants to support parallel loading, it needs to register itself. If the user-defined loader needs to load in parallel, it needs to configure itself. By calling registerAsParallelCapable ()

At this point, I believe you have a deeper understanding of "what is the class loader of JVM". 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.