What is the JVM?

Roughly, the INTERNAL architecture of the JVM is divided into three parts: the ClassLoader subsystem, the runtime data area, and the execution engine.

Class loader

Each Java VIRTUAL machine is provided by a Class loader subsystem that takes care of the types (classes and interfaces) within the program and assigns them unique names. Each Java virtual machine has an execution engine that executes the instructions contained in the loaded class. The two types of JVM loaders are startup class loaders, which are part of the JVM implementation, and user-defined class loaders, which are part of Java programs and must be subclasses of the ClassLoader class.

Execution engine: It either executes bytecode or executes local methods

The main execution techniques are: interpretation, just-in-time compilation, adaptive optimization, and cha-level direct execution. Interpretation belongs to the first-generation JVM, just-in-time compilation belongs to the second-generation JVM, and adaptive optimization (currently Sun’s HotspotJVM uses this technology) combines the experience of first-generation and second-generation JVMS.

Adaptive optimization: Start with all code interpreted and monitored, then start a background thread for frequently invoked methods, compile them into native code, and carefully optimize them. If the method is no longer used frequently, the compiled code is cancelled and interpreted execution continues.

Runtime data area: mainly includes: method area, heap, Java stack, PC register, local method stack

• The method area and heap are shared by all threads

Heap: Holds objects created by all programs at run time

Method area: When the JVM’s classloader loads a. Class file and parses it, it puts the parsed type information into the method area.

• The Java stack and PC registers are exclusive to the thread

The JVM stack is thread private. Each thread is created with the JVM stack, which holds variables of the local primitive types in the current thread. Boolean, char, byte, short, int, long, float, double), partial return results, and Stack frames. Objects of non-basic types only hold one address on the JVM Stack that points to the heap

• Local method stack: Stores the state of local method calls

Since the data area of the JVM runtime is a particularly important part of our development, we’ll take it apart.

• Method Area

In the Sun JDK, this area corresponds to PermanetGeneration, also known as persistent generation.

The method area stores information about the loaded Class (name, modifiers, etc.), static variables in the Class, constants defined as final types in the Class, Field information in the Class, and method information in the Class. When the developer obtains information through getName, isInterface and other methods in the Class object in the program, This data comes from the method region, which is also globally shared and is GC under certain conditions. An OutOfMemory error message is raised when the method region needs more memory than it allows.

• Heap (Heap)

It is the area where the JVM stores object instances as well as array values, and it can be considered that memory for all objects created by New in Java is allocated there, while memory for objects in Heap is waiting for GC to collect.

The heap is shared by all threads in the JVM, so allocating object memory on it requires locking, which also causes the overhead of new objects to be high.

The Sun Hotspot JVM allocates an independent TLAB (Thread Local Allocation Buffer) to the threads it creates in order to improve the efficiency of object memory Allocation. The TLAB size is calculated by the JVM according to the running situation. There is no lock required to allocate objects on TLAB, so the JVM tries to allocate memory on TLAB when allocating objects on thread. In this case, the PERFORMANCE of allocating object memory in JVM is almost as efficient as that of C, but if the object is too large, it still uses heap space allocation directly.

TLAB only works with the new generation of Eden Space, so when writing Java programs, it is often more efficient to allocate multiple small objects rather than large ones.

• JavaStack(Javastack) : The virtual machine will only perform two operations directly on the JavaStack: push or push on a frame-by-frame basis

Each frame represents a method, and a Java method has two ways to return it, return and throw an exception. Both ways cause the frame corresponding to the method to go off the stack and free memory.

Frame: the local variable area (including the method parameters and local variables, for instance methods, but also the first save this type, including the method parameters strictly in declaration order placed, local variables can be arbitrarily placed), the operand stack, the frame data area (to help support the constant pool parsing, returned to normal method and exception handling).

• ProgramCounter

Each thread has its own PC register, which is created when the thread is started. The contents of the PC register always point to the address of the next instruction to be executed, which can be either a local pointer or an offset in the method area that corresponds to the start instruction of the method.

If Thread executes a Java method, the PC saves the address of the next execution instruction. If thread executes native methods, the value of Pc is undefined

• Nativemethodstack: Stores the address of the native method into the region

Depending on the implementation of a local method, such as the local method of a JVM implementation using the C-connection model, the local method stack is the C stack, so to say that when a thread calls a local method, it enters a jVM-free realm, that is, the JVM can use local methods to dynamically extend itself.