What is JVM?

JVM is the abbreviation of Java Virtual Machine (Java Virtual Machine). JVM is a specification for computing devices. It is a fictitious computer that is simulated through simulation on an actual computer. various computer functions. The Java virtual machine includes a set of bytecode instructions, a set of registers, a stack, a garbage collection heap and a storage method field.

JVM shields information related to specific operating system platforms, so that Java programs only need to generate target code (bytecode) that runs on the Java virtual machine, and can be run on multiple platforms without modification. run. When the JVM executes bytecode, it actually ultimately interprets the bytecode into machine instructions for execution on the specific platform.

JVM memory area

When running, the JVM will divide the memory it manages into multiple areas, each area has its own purpose and life cycle. Let’s break them down one by one based on the memory partition pictures:

Program Counter Register

The program counter occupies a small amount of memory. Its role can be seen as an indicator of the bytecode executed by the current thread. By changing the value of the counter, the next bytecode instruction can be obtained.

When the program counter executes the Native method, the value of the counter is empty (undefined).

The program counter is thread-private, and each thread will be assigned one.

Online video tutorial sharing: java learning

Virtual machine stack (VM Stack)

The virtual machine stack is executed by the JVM Java method service. When each method is executed, a stack frame will be created to store local variable table, operand stack, dynamic link, method exit and other information. From the call to the end of execution of each method, it corresponds to the process of pushing a stack frame from the virtual machine stack to popping it out.

The local variable table of the virtual machine stack stores the following data:

Basic type data (boolean, byte, char, short, int, float, long, double)

Object reference (reference type)

returnAddress type (pointing to the address of a bytecode instruction)

It should be noted that the memory space required for the local variable table has been determined during compilation , the size will no longer change.

The virtual machine stack is also thread-private, and each thread will be assigned one.

JVM specifies two exceptions for the virtual machine stack:

StackOverflowError: The stack depth requested by the thread is greater than the depth allowed by the virtual machine.

OutOfMemoryError: If the virtual machine stack can be dynamically expanded, but insufficient memory cannot be applied for during expansion.

Native Method Stack

The local method stack is similar to the virtual machine stack. The main difference is that the local method stack specifically provides services for Native methods.

Native method: The method declared by the Native keyword in java, implemented in non-java language, refers to the third-party language method provided by the local library.

The local method stack is also thread-private, and each thread will allocate one.

Heap

The heap is a memory area shared by all threads. It is created when the JVM starts. It is generally the largest piece of space in the JVM. The garbage collector ( The main area managed by GC).

The main data stored in the heap is:

Object

Array

The heap can be physically discontinuous, but as long as it is logically continuous , thus an expandable memory area.

When the heap memory size is not enough to create an object or array and cannot be expanded, an OutOfMemoryError exception will be thrown.

Method Area

The method area is also a memory area shared by all threads.

The main data stored in the method area is:

Class information that has been loaded by the JVM

Constant (starting from jdk1.7, the runtime constant pool has been moved to the heap)

Static variables

Code and other data compiled by just-in-time compiler

Garbage collector (GC) rarely appears in this area, and the main memory recycling target is the constant pool Recycling and unloading of types.

When the method area cannot meet the memory allocation requirements, an OutOfMemoryError exception will be thrown.

Constant Pool (Runtime Constant Pool)

The constant pool is part of the method area and is used to store various literals and symbol references generated during compilation. Constants can be put into the pool at both compile time and run time (String's intern()). The memory is limited and an OutOfMemoryError exception is thrown when it cannot be applied for.

Starting from jdk1.7, the runtime constant pool has been moved to the heap.

Direct Memory

Direct memory is not the JVM runtime memory data area, nor is it memory defined in the JVM specification.

Direct memory occupies the size of physical memory. You need to pay attention to include direct memory when allocating JVM memory. Otherwise, an OutOfMemoryError exception may occur when dynamically expanding memory.

Recommended related article tutorials: Getting started with java

The above is the detailed content of Division of memory areas in java. For more information, please follow other related articles on the PHP Chinese website!