【JVM】Java 虚拟机原理和架构、JVM指令集
目录
JVM – Java 虚拟机工作和架构：JVM – Java Virtual Machine Working and Architecture
What is JVM – Java Virtual Machine?什么是 JVM——Java 虚拟机？
Need for Java Virtual Machine 需要 Java 虚拟机
JVM Architecture in Java Java 中的 JVM 架构
Execution Engine in Java Java 中的执行引擎
Native Method interface 本机方法接口
Difference Between JDK, JRE, And JVMJDK、JRE 和 JVM 之间的区别
JVM 指令集清单
JVM – Java 虚拟机工作和架构：JVM – Java Virtual Machine Working and Architecture
In this Java tutorial, we are going to discuss Java Virtual Machine(JVM), which is one of the most important aspects of Java programming language.
在本 Java 教程中，我们将讨论 Java 虚拟机 (JVM)，它是 Java 编程语言最重要的方面之一。
We will study about JVM architecture and its subsystems. We also briefly discuss what a Java Virtual Machine is and how it works.
我们将研究 JVM 体系结构及其子系统。我们还将简要讨论什么是 Java 虚拟机及其工作原理。
Moreover, we will discuss Java Classloader, an executive engine in Java, the Java Memory Model, and the JVM screen in detail.
此外，我们将详细讨论 Java 类加载器、Java 中的执行引擎、Java 内存模型和 JVM screen？
What is JVM – Java Virtual Machine?
什么是 JVM——Java 虚拟机？
As we all know that we need to either compile or interpret any source code before executing it. But Java uses the combination of both, i.e, compiler as well as interpreter.
众所周知，我们需要在执行任何源代码之前对其进行编译或解释。但是 Java 使用两者的组合，即编译器和解释器。
Java programs are first compiled into Java Byte Code(Binary form) and then a special Java interpreter interprets them for a specific platform.
Java 程序首先被编译成 Java 字节码（二进制形式），然后由一个特殊的 Java 解释器为特定的平台解释它们。
Java ByteCode is the machine language for Java Virtual machine(JVM). The JVM converts the compiled binary byte code into a specific machine language.
Java 字节码是 Java 虚拟机 (JVM) 的机器语言。 JVM 将编译后的二进制字节码转换成特定的机器语言。
TIPS：Java 字节码 具体长什么样？
Java字节码是Java程序编译后生成的二进制文件，其中包含了Java程序的指令集。字节码文件的扩展名为.class，可以在Java虚拟机（JVM）上被解释执行。
Java字节码由一系列的字节码指令组成，每个字节码指令都是一个字节的长度，用于表示一种特定的操作。例如，常见的字节码指令包括 load、store、add、mul、if、goto 等等。
下面是一个简单的Java程序的字节码示例：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, world!");
}
}
对应的字节码如下：
CA FE BA BE 00 00 00 34 00 12 0A 00 03 00 0D 07
00 0E 07 00 0F 01 00 06 3C 69 6E 69 74 3E 01 00
03 28 29 56 01 00 04 43 6F 64 65 01 00 0F 4C 69
6E 65 4E 75 6D 62 65 72 54 61 62 6C 65 01 00 12
4C 6F 63 61 6C 56 61 72 69 61 62 6C 65 54 61 62
6C 65 01 00 04 74 68 69 73 01 00 15 4C 48 65 6C
6C 6F 2C 20 77 6F 72 6C 64 21 0A 01 00 0A 53 6F
75 72 63 65 46 69 6C 65 01 00 0E 48 65 6C 6C 6F
57 6F 72 6C 64 2E 6A 61 76 61 0A 00 03 00 11 0C
00 05 00 06 01 00 0F 4A 61 76 61 2F 6C 61 6E 67
2F 4F 62 6A 65 63 74 07 00 10 01 00 0A 48 65 6C
6C 6F 57 6F 72 6C 64 07 00 12 01 00 0C 6A 61 76
61 2F 69 6F 2F 50 72 69 6E 74 6C 6E 01 00 15 6A
61 76 61 2F 6C 61 6E 67 2F 53 79 73 74 65 6D 45
78 69 74 3B 01 00 10 6A 61 76 61 2F 69 6F 2F 46
69 6C 65 4F 75 74 70 75 74 01 00 10 6A 61 76 61
2F 69 6F 2F 50 72 69 6E 74 53 74 72 65 61 6D 01
00 0B 6A 61 76 61 2F 69 6F 2F 53 79 73 74 65 6D
01 00 10 6A 61 76 61 2F 6C 61 6E 67 2F 4F 62 6A
65 63 74 3B 00 21 00 02 00 03 00 00 00 00 00 01
00 01 00 04 00 05 00 01 00 06 00 00 00 1F 00 01
00 01 00 00 00 05 2A B7 00 01 B1 00 00 00 02 00
07 00 00 00 06 00 01 00 00 00 03 00 08 00 09 00
01 00Java Virtual machine acts as a subpart of Java Runtime Environment(JRE).
Java 虚拟机充当 Java 运行时环境 (JRE) 的子部分。
The JVM is an abstract machine that works on the top of existing processes. We can implement it in hardware or software.
JVM 是一个在现有进程之上工作的抽象机器。我们可以用硬件或软件来实现它。
JVM combined with Java APIs makes Java Platform. The essential use of the JVM is HotSpot.
JVM 结合 Java API 构成了 Java 平台。 JVM 的基本用途是 HotSpot。
We can define JVM in three ways:
我们可以通过三种方式定义 JVM：
1. A specification that specifies the working of Java Virtual Machine. The one who provides the implementation is independent to choose the algorithm.
1. 指定 Java 虚拟机工作的规范。提供实现的人可以独立选择算法。
2. An Implementation called the Java Runtime Environment (JRE).
2. 称为 Java 运行时环境 (JRE) 的实现。
3. A Runtime Instance that creates a JVM instance when you write a command on the command prompt to run the java class.
3. Runtime Instance，当你在命令提示符下写命令运行java类时创建一个JVM实例。
Working of JVM - JVM的工作
JVM(Java Virtual Machine) behaves as a run-time engine to run Java applications. JVM calls the main method present in Java code.
JVM（Java 虚拟机）作为一个运行时引擎来运行 Java 应用程序。 JVM 调用 Java 代码中的主要方法。
Java Virtual machine(JVM) is a part of the JRE(Java Runtime Environment).
Java虚拟机（JVM）是JRE（Java Runtime Environment）的一部分。
Java applications are WORA (Write Once Run Anywhere). This means that we need to write the Java programs just once, which we can run on different platforms without making changes in the Java program.
Java 应用程序是 WORA（一次编写，随处运行）。这意味着我们只需编写一次 Java 程序，我们就可以在不同的平台上运行，而无需对 Java 程序进行更改。
When we compile a .java file, the compiler generates the .class files(contains byte-code) with the same names as that of the class present in a .java file.
当我们编译 .java 文件时，编译器会生成 .class 文件（包含字节码），其名称与 .java 文件中存在的类的名称相同。
When we run a .class file, it goes through various steps.
当我们运行一个 .class 文件时，它会经历多个步骤。
Need for Java Virtual Machine 需要 Java 虚拟机
The need for Java Virtual Machine is to handle the tasks that it performs which are necessary for the development of programs involving Java. Java virtual machine performs the following tasks:
Java 虚拟机的需要是处理它执行的任务，这些任务是开发涉及 Java 的程序所必需的。 Java 虚拟机执行以下任务：
- Loads the code. 加载代码。
- Verifies code. 验证码。
- Executes the code. 执行代码。
- Provides a run-time environment for various applications.
为各种应用程序提供运行时环境。 - JVM provides a Memory area. JVM 提供了一个内存区域。
- Provides a Register set. 提供寄存器组。
-
JVM provides the garbage collection heap.
JVM 提供了垃圾收集堆。 - Reports fatal errors. 报告致命错误。
- Provides a class file format 提供类文件格式
All these tasks make the Java virtual machine an integral part of Java development.
所有这些任务使 Java 虚拟机成为 Java 开发的一个组成部分。
JVM Architecture in Java Java 中的 JVM 架构
There are three main subsystems in JVM Architecture:
JVM Architecture 中主要有三个子系统：
1. ClassLoader 1.类加载器
2. Memory Area 2.内存区
3. Execution Engine 3. 执行引擎
Now, we will understand each of them in detail.
现在，我们将详细了解它们中的每一个。
Java ClassLoader Java类加载器
It is the component of JVM Architecture that loads classes in memory. Every JVM consists of a ClassLoader. Three built-in classloaders in Java are:
它是 JVM Architecture 的组件，用于在内存中加载类。每个 JVM 都包含一个 ClassLoader。 Java 中的三个内置类加载器是：
1. Bootstrap ClassLoader 1.引导类加载器
This is the classloader which is the super class of Extension classloader. It loads the rt.jar file.
这是类加载器，它是扩展类加载器的超类。它加载 rt.jar 文件。
2. Extension ClassLoader 2.扩展类加载器
It is the ClassLoader which loads the jar files present in the directory. This is the child Bootstrap classLoader and parent of System classloader.
加载目录中存在的 jar 文件的是 ClassLoader。这是子 Bootstrap 类加载器和系统类加载器的父类。
3. System/Application ClassLoader
3. 系统/应用类加载器
It is the classLoader which loads the class files from the classpath. This is the child of the Extension classloader.
它是从类路径加载类文件的类加载器。这是扩展类加载器的子类。
The Three important functions of ClassLoader are Initialization, Loading, Linking.
ClassLoader的三个重要功能是Initialization，Loading，Linking。
1. Initialization 1.初始化
This operation involves the assignment of all static variables with their specific values in the block of the program.
此操作涉及为所有静态变量分配程序块中的特定值。
In this phase, there is an assignment of all static variables with their values defined in the code and static block.
在此阶段，对所有静态变量进行赋值，其值在代码和静态块中定义。
The execution takes place from top to bottom in a class and from parent to child in the class hierarchy.
执行在类中从上到下发生，在类层次结构中从父到子发生。
2. Load4ing 2.加载
This operation loads files from secondary memory into the main memory (RAM) for execution. The Classloader reads the .class file, generates the corresponding binary data, and saves it in the method area.
此操作将文件从辅助内存加载到主内存 (RAM) 中以供执行。 Classloader读取.class文件，生成相应的二进制数据，保存在方法区。
JVM stores some information for each .class file in the method area. This information is:
JVM 在方法区中存储了每个.class 文件的一些信息。此信息是：
- The fully qualified name of the loaded class and its immediate parent class.
加载类及其直接父类的完全限定名称。 - Whether .class file is related to interface or an enum or a class.
.class 文件是否与接口、枚举或类相关。 - Modifier, Variables and Method information, etc.
修饰符、变量和方法信息等。
After loading the .class file, JVM creates an object of type Class to represent this file in the heap memory.
加载.class文件后，JVM会在堆内存中创建一个Class类型的对象来表示这个文件。
The programmers can use this Class object for getting class level information like the name of the class, parent name, methods, and variable information, etc.
程序员可以使用这个 Class 对象来获取类级别的信息，如类名、父类名称、方法和变量信息等。
To get this object reference we can use the getClass() method of Object class.
要获取此对象引用，我们可以使用 Object 类的 getClass() 方法。
3. Linking 3.链接
This operation combines different files in the main program together. It performs verification, preparation, and (optionally) resolution.
此操作将主程序中的不同文件组合在一起。它执行验证、准备和（可选）解决方案。
- Verification: The Verification phase checks the correctness of the .class file. It means that it checks that the file formation and generation is by a valid compiler or not. If the verification fails then we get a java.lang.Verify Exception.
验证：验证阶段检查.class 文件的正确性。这意味着它检查文件的形成和生成是否由有效的编译器进行。如果验证失败，那么我们会得到一个 java.lang.Verify 异常。 - Preparation: JVM allocates memory for class variables and initializes the memory to default values.
准备工作：JVM为类变量分配内存，并将内存初始化为默认值。 - Resolution: Resolution is the process of replacing symbolic references with direct references. It uses searching into the method area to locate the referenced entity.
解析：解析是用直接引用替换符号引用的过程。它使用搜索方法区来定位引用的实体。
Code to demonstrate ClassLoader in Java:
在 Java 中演示 ClassLoader 的代码：
Let us see an example to print the classloader name
让我们看一个打印类加载器名称的示例
<span style="color:#444444"><span style="background-color:#ffffff">package com.techvidvan.jvm;
public class Test1 {
public static void main(String[] args) {
// Let's print the classloader name of the current class.
//Application/System classloader will load this class
Class c = Test1.class;
System.out.println(c.getClassLoader());
//If we print the classloader name of String, it will print null because it is an
//in-built class which is present in rt.jar, Bootstrap classloader loads it.
System.out.println(String.class.getClassLoader());</span></span>Output: 输出：
sun.misc.Launcher$AppClassLoader@659e0bfd
null 无效的
JVM Memory area JVM内存区
1. Method Area– It stores the structure of each class like method data, field data, runtime pool, metadata.
1. 方法区——它存储每个类的结构，如方法数据、字段数据、运行时池、元数据。
2. Heap– Heap is the runtime area where object allocation takes place.
2. 堆——堆是对象分配发生的运行时区域。
3. Stacks– Stacks store the partial results and local variables of a program. Whenever a thread is created, there is a simultaneous creation of JVM stack. When we invoke a method, a new frame creates and destroys at the same time when the invocation process completes.
3. 栈——栈存储程序的部分结果和局部变量。每当创建线程时，都会同时创建 JVM 堆栈。当我们调用一个方法时，一个新的框架会在调用过程完成时同时创建和销毁。
4. PC Registers – It stores the address of the currently executing JVM instruction.
4. PC Registers——存放当前正在执行的JVM指令的地址。
5. Native Method Stacks – It includes all the native methods required in any application. It is not written in java.
5. Native Method Stacks——它包括任何应用程序所需的所有本地方法。它不是用java编写的。
Execution Engine in Java Java 中的执行引擎
It is the component of JVM that reads data from memory locations and executes the instructions. It has three major components namely a virtual processor, an interpreter, and a JIT compiler.
它是 JVM 的组件，从内存位置读取数据并执行指令。它具有三个主要组件，即虚拟处理器、解释器和 JIT 编译器。
1. Virtual Processor 1. 虚拟处理器
2. Interpreter: Read the bytecode stream then execute the instructions.
2.解释器：读取字节码流然后执行指令。
3. Just-In-Time(JIT) compiler: It improves performance. JIT compiles parts of the byte code with similar functionality at the same time and reduces the amount of time needed for compilation.
3. Just-In-Time(JIT)编译器：提高性能。 JIT 同时编译具有相似功能的部分字节码，减少了编译所需的时间。
Native Method interface 本机方法接口
It is a framework that helps in communication between different applications written in different languages such as c, c++, etc.
它是一个框架，有助于在用不同语言（如 c、c++ 等）编写的不同应用程序之间进行通信。
Native Method Interface allows Java code running in a JVM to call by libraries and native applications.
Native Method Interface 允许在 JVM 中运行的 Java 代码被库和本机应用程序调用。
Method Libraries 方法库
Native Libraries is a collection of the Native Libraries(C, C++) which are essential for the Execution Engine.
本机库是执行引擎必不可少的本机库（C、C++）的集合。
Difference Between JDK, JRE, And JVM
JDK、JRE 和 JVM 之间的区别
The following are a few important differences between JDK, JVM, and JRE.
以下是 JDK、JVM 和 JRE 之间的一些重要区别。
1. JVM stands for Java Virtual machine, JDK stands for Java development kit, and JRE stands for Java runtime environment.
1、JVM代表Java虚拟机，JDK代表Java开发包，JRE代表Java运行环境。
2. JDK is for the development environment whereas JRE is for the run time environment.
2. JDK 用于开发环境，而 JRE 用于运行时环境。
3. JVM runs inside the JRE environment. JRE contains class libraries, Java Virtual Machine and other files other than development tools like compiler and debugger.
3. JVM 在JRE 环境中运行。 JRE 包含类库、Java 虚拟机和除编译器和调试器等开发工具之外的其他文件。
4. JRE is a subset of JDK. JDK contains JRE along with development tools such as compiler, debugger, etc.
4. JRE是JDK的一个子集。 JDK 包含 JRE 以及编译器、调试器等开发工具。
Important Points 要点
- JVM stands for Java Virtual Machine that drives the Java Code. It converts Java bytecode into machine language.
JVM 代表驱动 Java 代码的 Java 虚拟机。它将 Java 字节码转换为机器语言。 - Here, Java code is compiled to bytecode. This bytecode gets interpreted on different machines
在这里，Java 代码被编译为字节码。这个字节码在不同的机器上被解释 - JIT stands for a Just-in-time compiler. JIT is part of the Java Virtual Machine. It increases the execution time
JIT 代表即时编译器。 JIT 是 Java 虚拟机的一部分。它增加了执行时间 - Java may be slow in execution compared to other compiler machines,
与其他编译器机器相比，Java 的执行速度可能很慢，
Conclusion 结论
Here we come to the end of the JVM tutorial, where we learned about the Java Virtual machine in detail.
JVM 教程到这里就结束了，在这里我们详细了解了 Java 虚拟机。
Moreover, we discussed the architecture and its subtypes. We also learned the differences between the important terms- JDK,JRE, and JVM.
此外，我们还讨论了体系结构及其子类型。我们还了解了重要术语 JDK、JRE 和 JVM 之间的区别。
JVM 指令集
| 字节码 | 助记符 | 指令含义 |
| 0x00 | nop | None |
| 0x01 | aconst_null | 将null推送至栈顶 |
| 0x02 | iconst_m1 | 将int型-1推送至栈顶 |
| 0x03 | iconst_0 | 将int型0推送至栈顶 |
| 0x04 | iconst_1 | 将int型1推送至栈顶 |
| 0x05 | iconst_2 | 将int型2推送至栈顶 |
| 0x06 | iconst_3 | 将int型3推送至栈顶 |
| 0x07 | iconst_4 | 将int型4推送至栈顶 |
| 0x08 | iconst_5 | 将int型5推送至栈顶 |
| 0x09 | lconst_0 | 将long型0推送至栈顶 |
| 0x0a | lconst_1 | 将long型1推送至栈顶 |
| 0x0b | fconst_0 | 将float型0推送至栈顶 |
| 0x0c | fconst_1 | 将float型1推送至栈顶 |
| 0x0d | fconst_2 | 将float型2推送至栈顶 |
| 0x0e | dconst_0 | 将double型0推送至栈顶 |
| 0x0f | dconst_1 | 将double型1推送至栈顶 |
| 0x10 | bipush | 将单字节的常量值(-128~127)推送至栈顶 |
| 0x11 | sipush | 将一个短整型常量(-32768~32767)推送至栈顶 |
| 0x12 | ldc | 将int,float或String型常量值从常量池中推送至栈顶 |
| 0x13 | ldc_w | 将int,float或String型常量值从常量池中推送至栈顶(宽索引) |
| 0x14 | ldc2_w | 将long或double型常量值从常量池中推送至栈顶(宽索引) |
| 0x15 | iload | 将指定的int型本地变量推送至栈顶 |
| 0x16 | lload | 将指定的long型本地变量推送至栈顶 |
| 0x17 | fload | 将指定的float型本地变量推送至栈顶 |
| 0x18 | dload | 将指定的double型本地变量推送至栈顶 |
| 0x19 | aload | 将指定的引用类型本地变量推送至栈顶 |
| 0x1a | iload_0 | 将第一个int型本地变量推送至栈顶 |
| 0x1b | iload_1 | 将第二个int型本地变量推送至栈顶 |
| 0x1c | iload_2 | 将第三个int型本地变量推送至栈顶 |
| 0x1d | iload_3 | 将第四个int型本地变量推送至栈顶 |
| 0x1e | lload_0 | 将第一个long型本地变量推送至栈顶 |
| 0x1f | lload_1 | 将第二个long型本地变量推送至栈顶 |
| 0x20 | lload_2 | 将第三个long型本地变量推送至栈顶 |
| 0x21 | lload_3 | 将第四个long型本地变量推送至栈顶 |
| 0x22 | fload_0 | 将第一个float型本地变量推送至栈顶 |
| 0x23 | fload_1 | 将第二个float型本地变量推送至栈顶 |
| 0x24 | fload_2 | 将第三个float型本地变量推送至栈顶 |
| 0x25 | fload_3 | 将第四个float型本地变量推送至栈顶 |
| 0x26 | dload_0 | 将第一个double型本地变量推送至栈顶 |
| 0x27 | dload_1 | 将第二个double型本地变量推送至栈顶 |
| 0x28 | dload_2 | 将第三个double型本地变量推送至栈顶 |
| 0x29 | dload_3 | 将第四个double型本地变量推送至栈顶 |
| 0x2a | aload_0 | 将第一个引用类型本地变量推送至栈顶 |
| 0x2b | aload_1 | 将第二个引用类型本地变量推送至栈顶 |
| 0x2c | aload_2 | 将第三个引用类型本地变量推送至栈顶 |
| 0x2d | aload_3 | 将第四个引用类型本地变量推送至栈顶 |
| 0x2e | iaload | 将int型数组指定索引的值推送至栈顶 |
| 0x2f | laload | 将long型数组指定索引的值推送至栈顶 |
| 0x30 | faload | 将float型数组指定索引的值推送至栈顶 |
| 0x31 | daload | 将double型数组指定索引的值推送至栈顶 |
| 0x32 | aaload | 将引用类型数组指定索引的值推送至栈顶 |
| 0x33 | baload | 将boolean或byte型数组指定索引的值推送至栈顶 |
| 0x34 | caload | 将char型数组指定索引的值推送至栈顶 |
| 0x35 | saload | 将short型数组指定索引的值推送至栈顶 |
| 0x36 | istore | 将栈顶int型数值存入指定本地变量 |
| 0x37 | lstore | 将栈顶long型数值存入指定本地变量 |
| 0x38 | fstore | 将栈顶float型数值存入指定本地变量 |
| 0x39 | dstore | 将栈顶double型数值存入指定本地变量 |
| 0x3a | astore | 将栈顶引用类型数值存入指定本地变量 |
| 0x3b | istore_0 | 将栈顶int型数值存入第一个本地变量 |
| 0x3c | istore_1 | 将栈顶int型数值存入第二个本地变量 |
| 0x3d | istore_2 | 将栈顶int型数值存入第三个本地变量 |
| 0x3e | istore_3 | 将栈顶int型数值存入第四个本地变量 |
| 0x3f | lstore_0 | 将栈顶long型数值存入第一个本地变量 |
| 0x40 | lstore_1 | 将栈顶long型数值存入第二个本地变量 |
| 0x41 | lstore_2 | 将栈顶long型数值存入第三个本地变量 |
| 0x42 | lstore_3 | 将栈顶long型数值存入第四个本地变量 |
| 0x43 | fstore_0 | 将栈顶float型数值存入第一个本地变量 |
| 0x44 | fstore_1 | 将栈顶float型数值存入第二个本地变量 |
| 0x45 | fstore_2 | 将栈顶float型数值存入第三个本地变量 |
| 0x46 | fstore_3 | 将栈顶float型数值存入第四个本地变量 |
| 0x47 | dstore_0 | 将栈顶double型数值存入第一个本地变量 |
| 0x48 | dstore_1 | 将栈顶double型数值存入第二个本地变量 |
| 0x49 | dstore_2 | 将栈顶double型数值存入第三个本地变量 |
| 0x4a | dstore_3 | 将栈顶double型数值存入第四个本地变量 |
| 0x4b | astore_0 | 将栈顶引用型数值存入第一个本地变量 |
| 0x4c | astore_1 | 将栈顶引用型数值存入第二个本地变量 |
| 0x4d | astore_2 | 将栈顶引用型数值存入第三个本地变量 |
| 0x4e | astore_3 | 将栈顶引用型数值存入第四个本地变量 |
| 0x4f | iastore | 将栈顶int型数值存入指定数组的指定索引位置 |
| 0x50 | lastore | 将栈顶long型数值存入指定数组的指定索引位置 |
| 0x51 | fastore | 将栈顶float型数值存入指定数组的指定索引位置 |
| 0x52 | dastore | 将栈顶double型数值存入指定数组的指定索引位置 |
| 0x53 | aastore | 将栈顶引用型数值存入指定数组的指定索引位置 |
| 0x54 | bastore | 将栈顶boolean或byte型数值存入指定数组的指定索引位置 |
| 0x55 | castore | 将栈顶char型数值存入指定数组的指定索引位置 |
| 0x56 | sastore | 将栈顶short型数值存入指定数组的指定索引位置 |
| 0x57 | pop | 将栈顶数值弹出(数值不能是long或double类型的) |
| 0x58 | pop2 | 将栈顶的一个(对于非long或double类型)或两个数值(对于非long或double的其他类型)弹出 |
| 0x59 | dup | 复制栈顶数值并将复制值压入栈顶 |
| 0x5a | dup_x1 | 复制栈顶数值并将两个复制值压入栈顶 |
| 0x5b | dup_x2 | 复制栈顶数值并将三个(或两个)复制值压入栈顶 |
| 0x5c | dup2 | 复制栈顶一个(对于long或double类型)或两个(对于非long或double的其他类型)数值并将复制值压入栈顶 |
| 0x5d | dup2_x1 | dup_x1指令的双倍版本 |
| 0x5e | dup2_x2 | dup_x2指令的双倍版本 |
| 0x5f | swap | 将栈顶最顶端的两个数值互换(数值不能是long或double类型) |
| 0x60 | iadd | 将栈顶两int型数值相加并将结果压入栈顶 |
| 0x61 | ladd | 将栈顶两long型数值相加并将结果压入栈顶 |
| 0x62 | fadd | 将栈顶两float型数值相加并将结果压入栈顶 |
| 0x63 | dadd | 将栈顶两double型数值相加并将结果压入栈顶 |
| 0x64 | isub | 将栈顶两int型数值相减并将结果压入栈顶 |
| 0x65 | lsub | 将栈顶两long型数值相减并将结果压入栈顶 |
| 0x66 | fsub | 将栈顶两float型数值相减并将结果压入栈顶 |
| 0x67 | dsub | 将栈顶两double型数值相减并将结果压入栈顶 |
| 0x68 | imul | 将栈顶两int型数值相乘并将结果压入栈顶 |
| 0x69 | lmul | 将栈顶两long型数值相乘并将结果压入栈顶 |
| 0x6a | fmul | 将栈顶两float型数值相乘并将结果压入栈顶 |
| 0x6b | dmul | 将栈顶两double型数值相乘并将结果压入栈顶 |
| 0x6c | idiv | 将栈顶两int型数值相除并将结果压入栈顶 |
| 0x6d | ldiv | 将栈顶两long型数值相除并将结果压入栈顶 |
| 0x6e | fdiv | 将栈顶两float型数值相除并将结果压入栈顶 |
| 0x6f | ddiv | 将栈顶两double型数值相除并将结果压入栈顶 |
| 0x70 | irem | 将栈顶两int型数值作取模运算并将结果压入栈顶 |
| 0x71 | lrem | 将栈顶两long型数值作取模运算并将结果压入栈顶 |
| 0x72 | frem | 将栈顶两float型数值作取模运算并将结果压入栈顶 |
| 0x73 | drem | 将栈顶两double型数值作取模运算并将结果压入栈顶 |
| 0x74 | ineg | 将栈顶int型数值取负并将结果压入栈顶 |
| 0x75 | lneg | 将栈顶long型数值取负并将结果压入栈顶 |
| 0x76 | fneg | 将栈顶float型数值取负并将结果压入栈顶 |
| 0x77 | dneg | 将栈顶double型数值取负并将结果压入栈顶 |
| 0x78 | ishl | 将int型数值左移指定位数并将结果压入栈顶 |
| 0x79 | lshl | 将long型数值左移指定位数并将结果压入栈顶 |
| 0x7a | ishr | 将int型数值右(带符号)移指定位数并将结果压入栈顶 |
| 0x7b | lshr | 将long型数值右(带符号)移指定位数并将结果压入栈顶 |
| 0x7c | iushr | 将int型数值右(无符号)移指定位数并将结果压入栈顶 |
| 0x7d | lushr | 将long型数值右(无符号)移指定位数并将结果压入栈顶 |
| 0x7e | iand | 将栈顶两int型数值"按位与"并将结果压入栈顶 |
| 0x7f | land | 将栈顶两long型数值"按位与"并将结果压入栈顶 |
| 0x80 | ior | 将栈顶两int型数值"按位或"并将结果压入栈顶 |
| 0x81 | lor | 将栈顶两long型数值"按位或"并将结果压入栈顶 |
| 0x82 | ixor | 将栈顶两int型数值"按位异或"并将结果压入栈顶 |
| 0x83 | lxor | 将栈顶两long型数值"按位异或"并将结果压入栈顶 |
| 0x84 | iinc | 将指定int型变量增加指定值(如i++, i--, i+=2等) |
| 0x85 | i2l | 将栈顶int型数值强制转换为long型数值并将结果压入栈顶 |
| 0x86 | i2f | 将栈顶int型数值强制转换为float型数值并将结果压入栈顶 |
| 0x87 | i2d | 将栈顶int型数值强制转换为double型数值并将结果压入栈顶 |
| 0x88 | l2i | 将栈顶long型数值强制转换为int型数值并将结果压入栈顶 |
| 0x89 | l2f | 将栈顶long型数值强制转换为float型数值并将结果压入栈顶 |
| 0x8a | l2d | 将栈顶long型数值强制转换为double型数值并将结果压入栈顶 |
| 0x8b | f2i | 将栈顶float型数值强制转换为int型数值并将结果压入栈顶 |
| 0x8c | f2l | 将栈顶float型数值强制转换为long型数值并将结果压入栈顶 |
| 0x8d | f2d | 将栈顶float型数值强制转换为double型数值并将结果压入栈顶 |
| 0x8e | d2i | 将栈顶double型数值强制转换为int型数值并将结果压入栈顶 |
| 0x8f | d2l | 将栈顶double型数值强制转换为long型数值并将结果压入栈顶 |
| 0x90 | d2f | 将栈顶double型数值强制转换为float型数值并将结果压入栈顶 |
| 0x91 | i2b | 将栈顶int型数值强制转换为byte型数值并将结果压入栈顶 |
| 0x92 | i2c | 将栈顶int型数值强制转换为char型数值并将结果压入栈顶 |
| 0x93 | i2s | 将栈顶int型数值强制转换为short型数值并将结果压入栈顶 |
| 0x94 | lcmp | 比较栈顶两long型数值大小, 并将结果(1, 0或-1)压入栈顶 |
| 0x95 | fcmpl | 比较栈顶两float型数值大小, 并将结果(1, 0或-1)压入栈顶; 当其中一个数值为NaN时, 将-1压入栈顶 |
| 0x96 | fcmpg | 比较栈顶两float型数值大小, 并将结果(1, 0或-1)压入栈顶; 当其中一个数值为NaN时, 将1压入栈顶 |
| 0x97 | dcmpl | 比较栈顶两double型数值大小, 并将结果(1, 0或-1)压入栈顶; 当其中一个数值为NaN时, 将-1压入栈顶 |
| 0x98 | dcmpg | 比较栈顶两double型数值大小, 并将结果(1, 0或-1)压入栈顶; 当其中一个数值为NaN时, 将1压入栈顶 |
| 0x99 | ifeq | 当栈顶int型数值等于0时跳转 |
| 0x9a | ifne | 当栈顶int型数值不等于0时跳转 |
| 0x9b | iflt | 当栈顶int型数值小于0时跳转 |
| 0x9c | ifge | 当栈顶int型数值大于等于0时跳转 |
| 0x9d | ifgt | 当栈顶int型数值大于0时跳转 |
| 0x9e | ifle | 当栈顶int型数值小于等于0时跳转 |
| 0x9f | if_icmpeq | 比较栈顶两int型数值大小, 当结果等于0时跳转 |
| 0xa0 | if_icmpne | 比较栈顶两int型数值大小, 当结果不等于0时跳转 |
| 0xa1 | if_icmplt | 比较栈顶两int型数值大小, 当结果小于0时跳转 |
| 0xa2 | if_icmpge | 比较栈顶两int型数值大小, 当结果大于等于0时跳转 |
| 0xa3 | if_icmpgt | 比较栈顶两int型数值大小, 当结果大于0时跳转 |
| 0xa4 | if_icmple | 比较栈顶两int型数值大小, 当结果小于等于0时跳转 |
| 0xa5 | if_acmpeq | 比较栈顶两引用型数值, 当结果相等时跳转 |
| 0xa6 | if_acmpne | 比较栈顶两引用型数值, 当结果不相等时跳转 |
| 0xa7 | goto | 无条件跳转 |
| 0xa8 | jsr | 跳转至指定的16位offset位置, 并将jsr的下一条指令地址压入栈顶 |
| 0xa9 | ret | 返回至本地变量指定的index的指令位置(一般与jsr或jsr_w联合使用) |
| 0xaa | tableswitch | 用于switch条件跳转, case值连续(可变长度指令) |
| 0xab | lookupswitch | 用于switch条件跳转, case值不连续(可变长度指令) |
| 0xac | ireturn | 从当前方法返回int |
| 0xad | lreturn | 从当前方法返回long |
| 0xae | freturn | 从当前方法返回float |
| 0xaf | dreturn | 从当前方法返回double |
| 0xb0 | areturn | 从当前方法返回对象引用 |
| 0xb1 | return | 从当前方法返回void |
| 0xb2 | getstatic | 获取指定类的静态域, 并将其压入栈顶 |
| 0xb3 | putstatic | 为指定类的静态域赋值 |
| 0xb4 | getfield | 获取指定类的实例域, 并将其压入栈顶 |
| 0xb5 | putfield | 为指定类的实例域赋值 |
| 0xb6 | invokevirtual | 调用实例方法 |
| 0xb7 | invokespecial | 调用超类构建方法, 实例初始化方法, 私有方法 |
| 0xb8 | invokestatic | 调用静态方法 |
| 0xb9 | invokeinterface | 调用接口方法 |
| 0xba | invokedynamic | 调用动态方法 |
| 0xbb | new | 创建一个对象, 并将其引用引用值压入栈顶 |
| 0xbc | newarray | 创建一个指定的原始类型(如int, float, char等)的数组, 并将其引用值压入栈顶 |
| 0xbd | anewarray | 创建一个引用型(如类, 接口, 数组)的数组, 并将其引用值压入栈顶 |
| 0xbe | arraylength | 获取数组的长度值并压入栈顶 |
| 0xbf | athrow | 将栈顶的异常抛出 |
| 0xc0 | checkcast | 检验类型转换, 检验未通过将抛出 ClassCastException |
| 0xc1 | instanceof | 检验对象是否是指定类的实际, 如果是将1压入栈顶, 否则将0压入栈顶 |
| 0xc2 | monitorenter | 获得对象的锁, 用于同步方法或同步块 |
| 0xc3 | monitorexit | 释放对象的锁, 用于同步方法或同步块 |
| 0xc4 | wide | 扩展本地变量的宽度 |
| 0xc5 | multianewarray | 创建指定类型和指定维度的多维数组(执行该指令时, 操作栈中必须包含各维度的长度值), 并将其引用压入栈顶 |
| 0xc6 | ifnull | 为null时跳转 |
| 0xc7 | ifnonnull | 不为null时跳转 |
| 0xc8 | goto_w | 无条件跳转(宽索引) |
| 0xc9 | jsr_w | 跳转至指定的32位offset位置, 并将jsr_w的下一条指令地址压入栈顶 |