[JVM] - memory partition in JVM

JVM Partition of memory area in

JVM After startup, a large memory area will be requested from the operating system , And then you need to do it according to the function , Divide this memory into different small areas .

One java In progress , May contain multiple threads , Between multiple threads , Share the same heap and method area , But each thread has its own stack and program counters ; Each process has its own heap , Multiple processes are not shared

Program counter

It is the smallest area in memory ： It saves the address of the next instruction to be executed by the current thread

Instructions , That is to say Bytecode , The program wants to run ,JVM You have to load the bytecode , Put it in memory , The program will take instructions out of memory one by one , Put it in CPU On the implementation , You need to keep in mind which one you are currently executing . This is because CPU It is a parallel program , It doesn't just serve one process , Serve all processes .（ This is equivalent to when we usually read , Which page did you see last , Just put the bookmark on that page , So that we can start from that page next time ）
Because the operating system schedules the execution in the unit of threads , Each thread has to record its execution location , therefore The program counter is one for each thread .

Stack

What's inside is mainly Local variables and method call information

When the method is called , Each time a new method is called , It all involves “ Push ” operation ; One method at a time , It's all about “ Out of the stack ” operation .
Be careful ： The stack space is actually small , Although in JVM The size of stack space can be configured in , But usually it is just a few M Or dozens M, So the stack is likely to be full . Write code normally , Generally nothing , Afraid of recursion , And the recursion condition is not set well , Then directly Stack overflow 了 StackOverflowException
Every thread has a stack

Pile up

There is only one copy of a process , Multiple threads share a heap , It is also the largest area in memory

new Out object , It's in the pile , Then the member variables of the object are naturally in the heap

Here we need to distinguish one thing that is easy to confuse ：

Variables of built-in type are on the stack , Variables of reference type are on the heap , Is this statement correct

The answer is incorrect , Local variables are on the stack , Member variables and new The objects of are on the heap , It doesn't matter what type of variable it is

Method area

Method area , It's “ Class object ”.
So-called “ Class object ” Namely ： What we wrote .java Such code will become .class（ Binary bytecode ）,.class Will be loaded into memory , It was JVM Constructed as a class object （ The loading process becomes “ Class loading ”）
There is another important thing in class objects , Static members —— By static Decorated member , Become “ Class properties ”, And ordinary members , be called “ Instance attributes ”

The class object describes what the class looks like ： What is the name of the class , Who's in it , What are the methods , What is the name and type of each member , yes public/private, What is the name and type of each method , yes public/private, Methods, etc