The JVM: (3) the runtime data area

3.1 Overview

This section mainly talks about the runtime data area, which is the part in the figure below, which is the stage after the class loading is completed

When we pass the previous stages: class loading -> verification -> preparation -> parsing -> initialization, the execution engine will be used to use our class, and the execution engine will useto our runtime data area

Memory is a very important system resource. It is the intermediate warehouse and bridge between the hard disk and the CPU. It carries the real-time running JVM memory layout of the operating system and applications.It ensures the efficient and stable operation of the JVM.Different JVMs have some differences in the way of memory division and management mechanism.Combined with the JVM virtual machine specification, let's discuss the classic JVM memory layout.

We compare the things behind the chef (cooked vegetables, knives, seasonings) to the runtime data area.And the chef can be analogous to the execution engine, making the prepared things into exquisite dishes

The data we get through the disk or network IO needs to be loaded into the memory first, and then the CPU gets the data from the memory for reading, which means that the memory acts as a bridge between the CPU and the disk

The Java virtual machine defines several runtime data areas that will be used during program execution, some of which will be created when the virtual machine starts and destroyed when the virtual machine exits.Others are one-to-one correspondence with threads, and these data areas corresponding to threads are created and destroyed as threads start and end.

Grey is private to a single thread, red is shared by multiple threads.That is:

• Each thread: independently includes program counter, stack, local stack.

• Inter-thread sharing: heap, off-heap memory (permanent generation or metaspace, code cache)

Each JVM has only one instance of Runtime, which is the runtime environment.

3.2 thread

A thread is a unit of execution in a program.The JVM allows an application to have multiple threads executing in parallel.In the Hotspot JVM, each thread maps directly to the operating system's native thread.

When a Java thread is ready to execute, an OS-native thread is also created at the same time.The native thread is also recycled after the Java thread execution terminates.

The operating system is responsible for scheduling all threads to any available CPU.Once the native thread is successfully initialized, it calls the run() method in the Java thread.

3.3 JVM system thread

If you use the console or any debugging tool, you can see that there are many threads running in the background.These background threads do not include the main thread that calls public static void main(String[] args) and all threads created by this main thread itself.

These main background system threads in the Hotspot JVM are mainly the following:

• Virtual machine thread: The operation of this thread requires the JVM to reach a safe point before it occurs.The reason these operations have to happen in different threads is that they all require the JVM to reach a safe point so the heap doesn't change.Such thread execution types include "stop-the-world" garbage collection, thread stack collection, thread suspension, and biased lock revocation.

• Periodic task threads: These threads are the embodiment of time-period events (such as interrupts), and they are generally used for scheduled execution of periodic operations.

• GC thread: This thread provides support for different kinds of garbage collection behavior in the JVM.

• Compiler thread: This thread compiles bytecode into native code at runtime.

• Signal Scheduling Thread: This thread receives signals and sends them to the JVM, which handles them internally by calling the appropriate method.