Roll up and break through the anxiety of 35 years old. The animation demonstrates how easy it is for the CPU to record the function call process and enter the Internet factory

hi Hello everyone , I am a DHL. official account ：ByteCode , Focus on sharing interesting hard core original content ,Kotlin、Jetpack、 performance optimization 、 System source code 、 Algorithm and data structure 、 Animation 、 Big factory surface

The full text is divided into Video version and Text version ,

Video version ：

Through voice and animation , Can see more intuitively , Memory records method calls and return procedures .

 bilibili Address : b23.tv/TQXL4xx

Text version

Have we ever thought about it while writing code How to call 、 How to return after the method is executed 、 How memory records method calls . This is also the key content of this article today .

Method calls and return procedures involve , Virtual machine stack 、 Program counter 、 Local variable table 、 The stack of operands 、 Method return address 、 Dynamic links and so on , There are many knowledge points involved , At the same time, these contents are also high-frequency interview questions , So I will split it into several articles , Make a detailed analysis of each knowledge point . In today's article, we will focus on how memory records method calls and return procedures .

Virtual machine stack

Java Method in the form of stack frame , Running on the virtual machine stack （Java Stack ） in , The stack is thread private , When the program starts , Will create a main Threads , The operating system allocates a section of memory for each thread , A virtual machine stack will be created when the thread is created , The life cycle of virtual machine stack is the same as that of thread , The thread is over , The virtual machine stack is also destroyed .

Every Java Method , Corresponding to each stack frame , So the method starts and ends , It is the process of putting and leaving stack frames one by one , The effect is shown below .

Stack frame

Every Java Method , All are stack frames , Each stack frame contains ： Local variable table 、 The stack of operands 、 Method return address 、 Dynamic links 、 Additional information .

• Local variable table ： Save the method parameter list and local variables in the method , Store... In the declared order , It is shown as an array , If it's an example method , The index for 0 yes this References to , As shown in the figure below .

Indexes （Slot）	name （Name）
0	this
1	num
2	res

• The stack of operands ： Save temporary results during method execution
• The return address ： Save the pc Register value （ namely JVM Instruction address ）, Used at the end of the method , Return to the use of transfer , Let the caller method continue to execute
• Dynamic links ： A reference to the method to which the stack frame belongs in the runtime constant pool , That is, find the symbolic reference of the target method from the constant pool , Then convert to direct reference
• Additional information ： Like a program debug Some attachment information added during （ Is not important , Don't care , Negligible ）

Here we only need to know their functions , Their data structure 、 Meaning of bytecode 、 Execution process, etc , In the following articles, I will make a detailed analysis of each knowledge point .

Method call procedure

First write a piece of code for method calls , The first call main() Call after method fun1() And then call fun2() , As shown in the figure below .

Now let's demonstrate Java The virtual machine performs these JVM Instruction process , The first call main () Method .

main () Method

main() Method execution process animation effect is as follows .

1. Execution instruction 0: aload_0, From the local variable table , Read index as 0 Value , Push into the operand stack , Because it's an instance method , So the index is 0 The value of is this References to

2. Execution instruction 1: iconst_5 , Constant 5 Push into the operand stack

3. Execution instruction 2: invokevirtual #7, Constant 5 and this Out of the operand stack , And then call this.fun1(5)

First, find the method from the constant pool fun1() Symbol reference for , Then the symbolic references are converted into direct references through dynamic links , Then call this.fun1(5), The method fun1() Push into the virtual machine stack as a stack frame , Jump to fun1(), So let's keep going .

How to find the symbolic reference of the target method from the constant pool , Then it is converted into a direct reference procedure , It will be analyzed in detail in a later series of articles

Calling fun1() Before ,fun1() The local variable table and method return address of have been determined .

How to get in fun1 (int num)

Method fun1(int num) The animation effect of the execution process is as follows .

1. Execution instruction 0: aload_0, From the local variable table , Read index as 0 Value , Push into the operand stack . Because it's an instance method , So the index is 0 The value of is this References to

2. Execution instruction 1: iload_1, From the local variable table , Read index as 1 Variable num Value , And push in the operand stack

3. Execution instruction 2: invokevirtual #13,num and this Out of the operand stack , And then call this.fun2(num)

First, find the method from the constant pool fun2() Symbol reference for , Then the symbolic references are converted into direct references through dynamic links , Then call this.fun2(num), The method fun2() Push into the virtual machine stack as a stack frame , Jump to fun2(), So let's keep going , call fun2() Before ,fun2() The local variable table and method return address of have been determined .

How to get in fun2 (int num)

Method fun2(int num) The animation effect of the execution process is as follows .

1. Execution instruction 0: iload_1, From the local variable table , Read index as 1 Variable num Value , And push it into the operand stack

2. Execution instruction 1: bipush , Constant 10 Push into the operand stack

3. Execution instruction 3: iadd ,num And constants 10 Out of the operand stack , And then add , Push the result into the operand stack

4. Execution instruction 4: istore_2, Take the result from the operand stack , And assign a value to the index in the local variable table as 2 The variable of res2

5. Execution instruction 5: iload_2, From the local variable table , Read index as 2 The variable of res2 Value , And push it into the operand stack

Method to exit the process

Each method is a stack frame , Each stack frame saves the method return address , perform return Series of instructions , The return address saved according to the current stack frame , Return to the location of the call , So let's keep going . So there are two situations .

Abnormal exit

If an exception occurs and is caught , Will look up from the exception table PC The address of the register （JVM Instruction address ）, Return to the call and continue to execute .

The following things will be done during normal exit

• Restore the local variable table of the previous stack frame 、 The stack of operands
• If there is a return value , Push the return value into the operand stack of the caller stack frame , Whether there is a return value depends on return JVM Instructions ：
  • ireturn ： The return value is boolean 、 byte 、 char 、 short and int type
  • lreturn ： The return value is Long type
  • freturn ： The return value is Float type
  • dreturn ： The return value is Double type
  • areturn ： The return value is a reference type
  • return ： The return value type is void
• Set the caller stack frame JVM Instruction address
• The current stack frame comes out of the virtual machine stack

In this article, we only analyze the normal exit process , The process of abnormal exit and normal exit is roughly the same . The animation effect of normal exit process is as follows .

1. Method fun2 At the end , Execute the last instruction ireturn , The current stack frame comes out of the virtual machine stack , The return address of the method saved according to the current stack frame , Back to fun1 , recovery fun1 The local variable table of 、 The stack of operands , Results will be returned res2 Save to caller （fun1） In the operand stack

2. Back to the method fun1(int num) , Execution instruction 5: istore_2, Variable res2 Out of the stack from the operand , The index assigned to the local variable table is 2 The variable of res1

3. Execution instruction 6: iload_2 , From the local variable table , Read index as 2 Variable res1 Value , And push it into the operand stack

4. Execution method fun1 The last instruction 7: ireturn, The current stack frame comes out of the virtual machine stack , The return address of the method saved according to the current stack frame , Back to main Method , recovery main Method's local variable table 、 The stack of operands , Results will be returned res2 Save to caller （main） In the operand stack

5. Finally, go back to the method main in , Execute the last instruction 5: pop, The elements in the operand stack are out of the stack

6. Execute the last instruction 6: return, So far, all the method calls are over , Method , Will also be returned to the system

Each method call , That is, the process of stack frame entering and leaving the stack , It also needs to occupy part of the memory , Used to save the local variable table 、 The stack of operands 、 Method return address 、 Dynamic links 、 Additional information, etc .

When the method is executed , That is, the stack frame comes out of the stack , Memory occupied by method calls , Will also be returned to the system .

This is the end of the article , Thanks for reading , If it helps , welcome Looking at 、 give the thumbs-up 、 Collection 、 Share To my friends .

I sincerely recommend you to pay attention to me , official account ：ByteCode , Continue to share hard core original content ,Kotlin、Jetpack、 performance optimization 、 System source code 、 Algorithm and data structure 、 Animation 、 Big factory surface .