Articles Catalogue
Deep Understanding of JVM Virtual Machine 5: Virtual Machine Bytecode Execution Engine
Original address: https://blog.csdn.net/a724888/article/details/78404643
I. The Essence of Method Call
Let's look at a piece of C code:
#include<stdio.h> void sayHello(int age) { int x = 32; int y = 2323; age = x + y; } void main() { int age = 22; sayHello(age); }
A very simple piece of code, we assemble and generate the corresponding assembly code, omitting part of the link code, leaving behind the core part:
main: pushl %ebp movl %esp, %ebp subl $20, %esp movl $22, -4(%ebp) movl -4(%ebp), %eax movl %eax, (%esp) call sayHello leave ret sayHello: pushl %ebp movl %esp, %ebp subl $16, %esp movl $32, -4(%ebp) movl $2323, -8(%ebp) movl -8(%ebp), %eax movl -4(%ebp), %edx addl %edx, %eax movl %eax, -12(%ebp) leave ret
The leave instruction is equivalent to the sum of the following two instructions:
movl %ebp %esp popl %ebp
2. Runtime stack frame structure
1. Table of Local Variables
Local variable table is different from operand stack, it uses index mechanism to access elements, but different from the way of operand stack's entry and exit stack. For example:
public void sayHello(String name){ int x = 23; int y = 43; x++; x = y - 2; long z = 234; x = (int)z; String str = new String("hello wrold "); }
2. Operator stack
3. Return address
4. Method calls
So which methods are static parsed and which methods need dynamic parsing?
For example, the following code:
Object obj = new String("hello"); obj.equals("world");
5. Static assignment
First, let's look at a piece of code:
public class Father { } public class Son extends Father { } public class Daughter extends Father { }
public class Hello { public void sayHello(Father father){ System.out.println("hello , i am the father"); } public void sayHello(Daughter daughter){ System.out.println("hello i am the daughter"); } public void sayHello(Son son){ System.out.println("hello i am the son"); } }
public static void main(String[] args){ Father son = new Son(); Father daughter = new Daughter(); Hello hello = new Hello(); hello.sayHello(son); hello.sayHello(daughter); }
6. Dynamic allocation
public class Father { public void sayHello(){ System.out.println("hello world ---- father"); } } public class Son extends Father { @Override public void sayHello(){ System.out.println("hello world ---- son"); } }
public static void main(String[] args){ Father son = new Son(); son.sayHello(); }
7. Support for Dynamic Type Properties
Object obj = new String("hello-world"); obj.split("-");
JDK 1.7 provides two ways to support Java's dynamic characteristics, invokedynamic instructions and the java.lang.invoke package. The implementation of the two methods is similar, we only introduce the basic content of the latter.
//This method is customized by me, not in the invoke package public static MethodHandle getSubStringMethod(Object obj) throws NoSuchMethodException, IllegalAccessException { //A method template is defined, which specifies the return value and parameter type of the method to be searched. MethodType methodType = MethodType.methodType(String[].class,String.class); //Method to find simple names and template information that match the specified method return lookup().findVirtual(obj.getClass(),"split",methodType).bindTo(obj); }
public static void main(String[] args){ Object obj = new String("hello-world"); //Location method and parameter execution method String[] strs = (String[]) getSubStringMethod(obj).invokeExact("-"); System.out.println(strs[0]); }
Deep Understanding of JVM Virtual Machine 6: Deep Understanding of JVM Class Loading Mechanism
Original address: https://blog.csdn.net/a724888/article/details/78396462
I. Timing of Class Loading
II. Class Loading Process
1. Loading
2. Verification
- File Format Verification
- Metadata validation
- Bytecode verification
- Symbol Reference Verification
3. Prepare
Assume that:
public static int value = 123;
A special case is that if the field property table contains the ConstantValue attribute, the value of the preparation phase variable is initialized to the value specified by the ConstantValue attribute, such as the value above if defined as:
public static final int value = 123;