JVM is the core of Java program operation, including runtime data area, class loading mechanism, bytecode execution engine and garbage collection mechanism. 1. The runtime data area includes method area (metaspace after JDK8), heap (used to store object instances and perform garbage collection), stack (save thread method call information), local method stack (supports Native methods) and program counter (records the current instruction address). 2. The class loading mechanism consists of three ClassLoaders, Bootstrap, Extension and Application. It follows the parent delegation model and goes through five stages: loading, verification, preparation, parsing and initialization in turn to ensure the security and uniqueness of class loading. 3. The bytecode execution engine runs code through interpretation execution and real-time compilation (JIT). HotSpot uses JIT to dynamically optimize hotspot code to improve performance. 4. The garbage collection mechanism adopts algorithms such as mark-clearing, copying, mark-collation. Modern JVM uses a generational collection strategy to divide the heap into the new generation and the old generation, and adopts suitable GC algorithms respectively. More efficient collectors such as G1 and ZGC can be selected according to the Full GC frequency and time. Mastering these four core modules helps to write efficient and stable Java applications and solve performance problems.

The Java virtual machine (JVM) is the core of Java program operation. It is responsible for loading classes, executing bytecode, and managing the program's runtime resources. Understanding the JVM architecture helps write more efficient and stable Java applications, and can also provide critical help when troubleshooting performance issues.

1. JVM runtime data area: the basic structure of program running

When running Java programs, the JVM divides out multiple memory areas, each of which assumes different responsibilities:

• Method Area : Store class information, constant pools, static variables, etc. In JDK8 and later, this part was replaced by metaspace.
• Heap : This is an area shared by all threads, mainly used to store object instances. Garbage recycling mainly happens here.
• Stack : Each thread has its own stack, which contains multiple stack frames. Each stack frame corresponds to a method call, saving local variables and operand stacks, etc.
• Native Method Stack : used to support the execution of Native methods.
• Program Counter Register : Records the address of the bytecode instruction executed by the current thread.

Understanding the role of these areas can help you locate problems like OutOfMemoryError or StackOverflowError faster.

2. Class loading mechanism: from class files to classes in memory

JVM does not load all classes into memory from the beginning, but loads them on demand. This process is completed by a class loader (ClassLoader) and mainly includes three parts:

• Bootstrap ClassLoader : Responsible for loading JDK core class libraries, such as the content in rt.jar .
• Extension ClassLoader : Loads the class in the jre/lib/ext directory or the class with a specified path.
• Application ClassLoader : also known as system class loader, responsible for loading classes on the user classpath.

The process of class loading includes five stages: loading, verification, preparation, parsing, and initialization. Among them, the "parent delegation model" is an important concept, which ensures that classes are not loaded repeatedly and also enhances security.

For example, when you write a custom java.lang.String class, the JVM will not use your version, but will prefer to use the standard classes provided by the Bootstrap loader.

3. Bytecode execution engine: How does JVM run code

The Java source code is compiled into bytecode ( .class file) and is then executed by the JVM. There are two main ways to execute JVM:

• Explanation execution : Read bytecode one by one and execute it.
• Instant Compilation (JIT) : Compile hotspot code (often executed code) into local machine code to improve execution efficiency.

The HotSpot virtual machine contains a JIT compiler, which will dynamically optimize code during operation. For example, the code in the loop body is easier to compile into machine code, thereby improving performance.

In addition, the execution engine also works in conjunction with the garbage collection system to automatically manage memory allocation and recycling.

4. Garbage collection mechanism: Who will clean up unused objects?

JVM automatically manages memory, and its core lies in the garbage collection mechanism (GC). The main task of GC is to identify and recycle objects that are no longer used and free up memory.

Common garbage collection algorithms are:

• Mark-Clear (Mark-Sweep)
• Copying
• Mark-Compact

Modern JVMs use generational collection strategies, usually dividing the heap into Young Generation and Old Generation, and different generations use different GC algorithms.

For example, the life cycle of the new generation objects is short, which is suitable for replication algorithms; the survival time of the old generation objects is long, which is suitable for marking and sorting.

If you find that you use Full GC frequently or GC for too long, you may need to adjust the heap size or choose a more suitable garbage collector, such as G1, ZGC, etc.

Basically that's it. The JVM architecture seems complex, but as long as you grasp these core modules, you can have a clear understanding of the Java program running mechanism.

The above is the detailed content of Deep Dive into the Java Virtual Machine Architecture. For more information, please follow other related articles on the PHP Chinese website!