JVM memory model
The memory space shown in the figure is divided into five parts:
1. Program counter
2. Java virtual machine stack
3. Local method stack
4. Heap
5. Method area
The following five methods are briefly explained:
1. Program counter
1.1 What is the program counter
The program counter is a small memory space, which can be used as a line number indicator of the bytecode being executed by the current thread, that is to say, does the program counter record the byte instruction being executed by the current thread? the address of
Note: If the current thread is executing a native method, then the program counter is empty at this time
1.2 The role of the program counter
There are two:
1. The bytecode interpreter reads and executes sequentially by changing the program counter, thereby realizing code flow control, such as sequential execution, selection, looping, and exception handling.
2. In the case of multi-threading, the program counter is used to record the execution position of the current thread, so that when the thread is switched back, it can know where the high thread ran last time.
1.3 Features of the program counter
1. It is a small storage space
2. Thread private. Each thread has a program counter
3. It is the only memory area that does not appear OutofMemoryError
4. The life cycle is created with the creation of the thread and dies with the end of the thread
2. Java Virtual Machine Stack (JVM Stack)
2.1 Concept of virtual machine stack:
The Java virtual machine stack is a memory model that describes the running process of Java methods.
The Java virtual machine stack will create an area called "stack frame" for each java method that is about to run. This area is used to store some information that the method needs during the running process, including:
- Local variable table
Stores basic data type variables, reference type variables, and returnAddress type variables. - operand stack
- dynamic link
- Method export information
- Wait
When a method is about to be executed, the Java virtual machine stack will first create a "stack frame" for the method in the Java virtual machine stack. The stack frame contains the local variable table, operand stack, dynamic link, method exit information, etc. When the method needs to create a local variable during the running process, the value of the local variable is stored in the local variable table of the stack frame.
When this method is executed, the stack frame corresponding to this method will be popped off the stack and the memory space will be released.
Note: People often say that Java's memory space is divided into "stack" and "heap". The stack stores local variables and the heap stores objects.
This sentence is not entirely correct! The "heap" here can be understood in this way, but the "stack" here only represents the local variable table part of the Java virtual machine stack. The real Java virtual machine stack is composed of stack frames, and each stack frame has: local variable table, operand stack, dynamic link, method exit information.
2.2. Features of Java Virtual Machine Stack
- The local variable table is created when the method is executed, along with the creation of the stack frame. Moreover, the size of the local variable table is determined at compile time, and it only needs to allocate a predetermined size when it is created. In addition, the size of the local variable table does not change while the method is running.
- There are two exceptions in the Java virtual machine stack: StackOverFlowError and OutOfMemoryError.
a) StackOverFlowError:
If the memory size of the Java virtual machine stack does not allow dynamic expansion, then when the depth of the thread request stack exceeds the maximum depth of the current Java virtual machine stack, a StackOverFlowError exception will be thrown.
b) OutOfMemoryError:
If the memory size of the Java virtual machine stack allows dynamic expansion, and the memory runs out when the thread requests the stack, it can no longer be dynamically expanded, and an OutOfMemoryError exception is thrown. - The Java virtual machine stack is also thread-private, and each thread has its own Java virtual machine stack, which is created as the thread is created, and dies as the thread dies.
Note: What are the similarities and differences between StackOverFlowError and OutOfMemoryError?
StackOverFlowError indicates that the stack applied by the current thread exceeds the preset maximum depth of the stack, but there may be a lot of memory space.
The OutOfMemoryError means that when the thread applies for the stack, it is found that the stack is full and the memory is all used up.
3. Native method stack
3.1. What is the native method stack?
The function implemented by the native method stack is similar to that of the Java virtual machine stack, except that the native method area is the memory model in which the native method runs.
When a native method is executed, a stack frame is also created in the native method stack to store the local variable table, operand stack, dynamic link, and exit information of the native method.
After the method is executed, the corresponding stack frame will be popped off the stack and the memory space will be released.
Also throws StackOverFlowError and OutOfMemoryError exceptions.
4. Heap
4.1. What is a heap?
The heap is the memory space used to store objects.
Almost all objects are stored on the heap.
4.2. Characteristics of the heap
- Thread sharing There is only one heap for
the entire Java virtual machine, and all threads access the same heap. The program counter, Java virtual machine stack, and native method stack are all for one thread. - Created at virtual machine startup
- The main place for garbage collection.
- It can be further subdivided into: new generation, old generation.
The new generation can be divided into: Eden, From Survior, To Survior.
Different areas hold objects with different life cycles. In this way, different garbage collection algorithms can be used according to different areas, which is more targeted and more efficient. - The size of the heap can be fixed or expandable, but the size of the mainstream virtual machine heap is expandable, so when a thread requests to allocate memory, but the heap is full, and the memory is full and cannot be expanded, an OutOfMemoryError is thrown.
5. Method area
5.1. What is a method area?
The Java Virtual Machine specification defines the method area as a logical part of the heap.
The method area stores class information, constants, static variables, and code compiled by the just-in-time compiler that have been loaded by the virtual machine.
5.2. Features of the method area
- Thread sharing The
method area is a logical part of the heap and, like the heap, is shared by threads. There is only one method area in the entire virtual machine. - The information in the permanent generation
method area generally needs to exist for a long time, and it is a logical partition of the heap. Therefore, using the method of dividing the heap, we call the method area the old generation. - Low memory recovery efficiency The information in the
method area generally needs to exist for a long time, and only a small amount of information may be invalid after the memory is recovered once.
The main goals of memory reclamation for the method area are: reclamation of the constant pool and unloading of types. - The Java virtual machine specification has looser requirements on the method area.
Like the heap, a fixed size is allowed, as well as an expandable size, and no garbage collection is implemented.
5.3. What is the runtime constant pool?
Three kinds of data are stored in the method area: class information, constants, static variables, and code compiled by the real-time compiler. where constants are stored in the runtime constant pool.
We generally declare a constant in a class through public static final. After this class is compiled, a Class file is generated, and all the information of this class is stored in this class file.
When the class is loaded by the Java virtual machine, the constants in the class file are stored in the runtime constant pool of the method area. And during runtime, new constants can be added to the constant pool. For example, the intern() method of the String class can add string constants to the constant pool during runtime.
When some constants in the runtime constant pool are not referenced by objects and are not referenced by variables, they need to be collected by the garbage collector.
6. Direct memory
Direct memory is memory other than the Java virtual machine, but may also be used by Java.
A channel and buffer-based IO method is introduced in NIO. It can directly allocate memory outside the Java virtual machine by calling a native method, and then directly operate the memory through a DirectByteBuffer object stored in the Java heap, without first copying the data in the external memory to the heap and then operating, thereby improving efficiency of data manipulation.
The size of direct memory is not controlled by the Java virtual machine, but since it is memory, an OOM exception will be thrown when the memory is insufficient.
In summary
- There are two "stacks" in the memory model of the Java virtual machine, namely: the Java virtual machine stack and the native method stack.
The functions of the two "stacks" are similar, and they are both memory models of the method running process. And the two "stacks" have the same internal structure and are both thread-private.
It's just that the Java virtual machine stack describes the memory model of the running process of Java methods, and the native method stack is the memory model that describes the running process of Java native methods. - There are two "heaps" in the memory model of the Java virtual machine, one is the original heap and the other is the method area. The method area is essentially a logical part of the heap. Objects are stored in the heap, and class information, constants, static variables, and code compiled by the real-time compiler are stored in the method area.
- The heap is the largest memory area in the Java virtual machine, and it is also the main working area of the garbage collector.
- The program counter, Java virtual machine stack, and native method stack are private to threads, that is, each thread has its own program counter, Java virtual machine stack, and native method area. And their life cycle is the same as the thread they belong to.
The heap and method area are shared by threads, and there is only one heap and one method stack in the Java virtual machine. It is created when the JVM starts, and is destroyed when the JVM stops.