1. Java compilation and interpretation process
(1) The java code is compiled and converted into a bytecode file (.class file) by the front end;
(2) The bytecode file is converted into machine language by the JVM's built-in compiler and run. This part uses different methods in unused JVMs. The following are two more frequently used methods:
1) Just-in-time complier (JIT: ​​just-in-time complier) is a dynamic compilation method that compiles and stores the hot spots in bytecode files, such as the C1 and C2 compilers of the HotSpot virtual machine;
2) Ahead-of-time complier is a static compilation method that compiles bytecode files and related libraries into machine language in advance.

2. The process of front-end compilation
(1) Analyze and fill the symbol table;
The process includes lexical analysis, syntax analysis and symbol table filling;
(2) The annotation processing of the plug-in annotation processor;
(3) Semantic analysis and bytecode generation;

3. The role of Java compilation execution and interpretation execution
(1) HotSpot VM is the virtual machine in Sun JDK and OpenJDK, and it is also the most widely used Java virtual machine.
But today's HotSpot VM not only has a built-in interpreter, but also a built-in advanced JIT (Just In Time Compiler) compiler. When the Java virtual machine is running, the interpreter and the just-in-time compiler can cooperate with each other to complement each other. One thing to note is that whether it is interpreted and executed by an interpreter or compiled and executed by a just-in-time compiler, the final bytecode needs to be converted into the native machine instructions of the corresponding platform.

(2) Since the JIT compiler is built into the HotSpot VM, why do we need to use an interpreter to "drag" the execution performance of the program?
For server-side applications, startup time is not the focus of attention, but for those application scenarios that value startup time, it may be necessary to adopt an architecture where an interpreter and a just-in-time compiler coexist in exchange for a balance.

(3) Since the just-in-time compiler postponed the compilation of local machine instructions to run time, the running performance of Java programs has reached a point where it can compete with C/C++ programs. This is mainly because the JIT compiler can deeply optimize the "hot code" that is frequently called, while the code optimization of the static compiler cannot fully infer runtime hotspots. Therefore, the local machine instructions compiled by the JIT compiler are more It is only natural that directly generated local machine instructions have higher execution efficiency.

4. Optimization of JIT compilation
　　 Java programs are initially interpreted and executed by an interpreter. When the virtual machine finds that a method or code block is running very frequently, it will regard these codes as "hot codes." In order to improve the execution efficiency of the hot code, at runtime, the virtual machine will compile these codes into machine code related to the local platform, and optimize the compiler to complete this task is called the even compiler.
Two ways to identify hot codes:
(1) Hot spot detection based on sampling
This method is to periodically probe the top of the thread stack. If a certain method is found to appear frequently, it is considered as a hot code;
(2) Hot spot detection based on counter
The virtual machine using this method establishes a counter for each method (even code block) to count the number of executions of the method. If the number of executions exceeds a certain threshold, it is considered a "hot method".