术语表是一项随着 HotSpot VM 发展而进行的工作，目前还在不断完善和维护。

adaptive spinning - 自适应旋转

An optimization technique whereby a thread spins waiting for a change-of-state to occur (typically a flag that represents some event has occurred - such as the release of a lock) rather than just blocking until notified that the change has occurred. The “adaptive” part comes from the policy decisions that control how long the thread will spin until eventually deciding to block.

一项优化技术，线程通过自我旋转来等待状态发生变化（通常表示释放锁），而不是一直阻塞直到状态改变。自适应体现在控制线程自旋转多长时间之后进入阻塞状态的策略。

biased locking - 偏向锁

An optimization in the VM that leaves an object as logically locked by a given thread even after the thread has released the lock. The premise is that if the thread subsequently reacquires the lock (as often happens), then reacquisition can be achieved at very low cost. If a different thread tries to acquire a biased lock then the bias must be revoked from the current bias owner.

一种虚拟机的优化技术，即使线程已经释放了锁，但还是使得对象在逻辑上给给定线程锁定。前提是如果线程随后重新获取锁（经常发生），那么可以以非常低的成本实现重新获取。 如果不同的线程尝试获取偏向锁，则必须从当前偏向所有者撤销该偏向。

synchronized 是基于操作系统的 mutex lock 实现的，每次获取和释放都需要进行用户态和内核态的切换，增加系统开销。因此，在竞争激烈的情况下，synchronized 同步锁在性能上就表现得很糟糕，常被称为重量级锁。

偏向锁假定 monitor 一直被某一个线程持有，直到另一个线程尝试获取它，这样就可以避免获取 monitor 时执行 cas 原子操作。当一个线程再次访问这个同步代码块合伙方法时，该线程只需要去对象头的 mark word 判断是否有偏向锁指向他的 ID，无需再进入 Monitor 去竞争对象了。当对象被当做同步锁并有一个线程抢到了锁时，锁标志位还是 01，“是否偏向锁”标志位设置为 1，并且记录抢到锁的线程 ID，表示进入偏向锁状态。

偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着，如果线程不处于活动状态，则将对象头设置成无锁状态，如果线程仍然活着，拥有偏向锁的栈会被执行，遍历偏向对象的锁记录，栈中的锁记录和对象头的Mark Word，要么重新偏向于其他线程，要么恢复到无锁或者标记对象不适合作为偏向锁，最后唤醒暂停的线程。

通过JVM 参数关闭偏向锁： -XX:-UseBiasedLocking //关闭偏向锁（默认打开） -XX:+UseHeavyMonitors //设置重量级锁

偏向锁在 JDK 15 中已经废弃：JEP 374: Disable and Deprecate Biased Locking

block start table - 块起始表

A table that shows, for a region of the heap, where the object starts that comes on to this region from lower addresees. Used, for example, with the card table variant of the remembered set.

一个表格，显示了堆的某个区域，从较低地址到达该区域的对象开始的位置。 例如，与记忆集的卡片表变体一起使用。

bootstrap classLoader - 引导类加载器

The logical classloader that has responsibility for loading the classes (and resources) that are found in the boot-classpath - typically the core Java platform classes. Typically implemented as part of the VM, by historical convention the bootstrap classloader is represented by NULL at the Java API level.

加载器，负责加载在 boot-classpath 目录下的类（和资源）- 特别是一些核心的类。VM 实现的典型部分，因为历史原因，引导类加载器在 Java API 级别由 NULL 表示。

bytecode verification - 字节码验证

类链接过程的一个步骤，其中分析方法字节码以确保类型安全。

C1 compiler - C1 编译器

Fast, lightly optimizing bytecode compiler. Performs some value numbering, inlining, and class analysis. Uses a simple CFG-oriented SSA “high” IR, a machine-oriented “low” IR, a linear scan register allocation, and a template-style code generator.

快速、轻量级的字节码编译器。 执行一些值编号、内联和类分析。 使用简单的面向 CFG 的 SSA“高”IR、面向机器的“低”IR、线性扫描寄存器分配和模板式代码生成器。

C2 compiler - C2 编译器

Highly optimizing bytecode compiler, also known as ‘opto’. Uses a “sea of nodes” SSA “ideal” IR, which lowers to a machine-specific IR of the same kind. Has a graph-coloring register allocator; colors all machine state, including local, global, and argument registers and stack. Optimizations include global value numbering, conditional constant type propagation, constant folding, global code motion, algebraic identities, method inlining (aggressive, optimistic, and/or multi-morphic), intrinsic replacement, loop transformations (unswitching, unrolling), array range check elimination.

高度优化的字节码编译器，也称为“opto”。 使用“节点海”SSA“理想”IR，它降低到同一类型的特定于机器的IR。 有一个图形着色寄存器分配器； 为所有机器状态着色，包括本地、全局和 存器和堆栈。 优化包括全局值编号、条件常量类型传播、常量折叠、全局代码运动、代数恒等式、方法内联（积极、乐观和/或多态）、内在替换、循环转换（取消切换、展开）、数组范围检查 消除。

card table - 卡片表

A kind of remembered set that records where oops have changed in a generation.

一类记忆集，记录对象指针在分代中的改变。

class data sharing - 类数据共享

A startup optimization that records the in-memory form of some classes, so that that form can be mapped into memory by a subsequent run of the virtual machine, rather than loading those classes from their class files.

一种启动优化，记录某些类的内存形式，以便该形式可以通过虚拟机的后续运行映射到内存中，而不是从它们的类文件中加载这些类。

class hierachy analysis - 类层次分析

Also known as ‘CHA’. Analysis of the class tree used by a compiler to determine if the receiver at a virtual call site has a single implementor. If so, the callee can be inlined or the compiler can employ some other static call mechanism.

通常称之为 CHA。分析编译器使用的类树，以确定虚拟调用站点的接收者是否只有一个实现者。如果是这样，被调用者可以被内联，或者编译器可以使用其他一些静态调用机制。

code cache - 代码缓存

A special heap that holds compiled code. These objects are not relocated by the GC, but may contain oops, which serve as GC roots.

一个保存了所有编译之后的代码的堆。这些对象不会被 GC 再分配，但可能包含 GC roots 的 oops。

compaction

A garbage collection technique that results in live objects occupying a dense portion of the virtual address space, and available space in another portion of the address space. Cf. free list.

一种垃圾回收技术，它导致存活对象占据虚拟地址空间的密集部分，而地址空间的另一部分属于可用空间。参见 免费列表。

concurrency - 并发

Concurrency, or more specifically concurrent programming, is the logical simultaneous execution of multiple instruction streams. If multiple processors are available then the logical simultaneity can be physical simultaneity - this is known as ‘parallelism’

并发，或者更具体地说是并发编程，是多个指令流的逻辑同时执行。如果有多个处理器可用，那么逻辑同时性可以是物理同时性——这被称为“并行性”

concurrent garbage collection - 并发垃圾收集

A garbage collection algorithm that does most (if not all) of its work while the Java application threads are still running.

一种垃圾收集算法，它在 Java 应用程序线程仍在运行时完成大部分（如果不是全部）工作。

copying garbage collection - 复制垃圾收集

A garbage collection algorithm that moves objects during the collection.

在收集期间移动对象的垃圾收集算法。

deoptimization - 去优化

The process of converting an compiled (or more optimized) stack frame into an interpreted (or less optimized) stack frame. Also describes the discarding of an nmethod whose dependencies (or other assumptions) have been broken. Deoptimized nmethods are typically recompiled to adapt to changing application behavior.

Example: A compiler initially assumes a reference value is never null, and tests for it using a trapping memory access. Later on, the application uses null values, and the method is deoptimized and recompiled to use an explicit test-and-branch idiom to detect such nulls.

将已编译（或优化程度更高）的堆栈帧转换为解释（或优化程度较低）堆栈帧的过程。还描述了依赖关系已被破坏的被遗弃的 nmethod。去优化的 nmethods 通常会重新编译以适应不断变化的应用程序行为。

示例：编译器最初假定引用值永远不会为空，并使用捕获内存访问对其进行测试。稍后，应用程序使用空值，并取消优化并重新编译该方法以使用显式测试和分支习语来检测此类空值。

dependency - 依赖

An optimistic assumption associated with an nmethod, which allowed the compiler to emit improved code into the nmethod.

Example: A given class has no subclasses, which simplifies method dispatch and type testing. The loading of new classes (or replacement of old classes) can cause dependencies to become false, which requires dependent nmethods to be discarded and activations of those nmethods to be deoptimized.

与 nmethod 相关的乐观假设，它允许编译器将改进的代码发送到 nmethod 中。

示例：给定的类没有子类，这简化了方法分派和类型测试。新类的加载（或旧类的替换）会导致依赖关系变为 false，这需要丢弃依赖的 nmethods 并取消优化这些 nmethods 的激活。

young generation - 年轻代

A region of the Java object heap that holds recently-allocated objects.

Java 对象堆的一个区域，用于保存最近分配的对象。

eden - 伊甸园区

A part of the Java object heap where object can be created efficiently.

可以高效创建对象的 Java 对象堆的一部分。

free list

A storage management technique in which unused parts of the Java object heap are chained one to the next, rather than having all of the unused part of the heap in a single block.

一种存储管理技术，其中 Java 对象堆的未使用部分被链接到下一个，而不是将堆的所有未使用部分都放在一个块中。

garbage collection - 垃圾收集

The automatic management of storage.

存储区的自动管理

garbage collection root- 垃圾收集根

A pointer into the Java object heap from outside the heap. These come up, e.g., from static fields of classes, local references in activation frames, etc.

从堆外部指向 Java 对象堆的指针。例如，这些来自类的静态字段、激活帧中的本地引用等。

GC map - GC 图

A description emitted by the JIT (C1 or C2) of the locations of oops in registers or on stack in a compiled stack frame. Each code location which might execute a safepoint has an associated GC map. The GC knows how to parse a frame from a stack, to request a GC map from a frame’s nmethod, and to unpack the GC map and manage the indicated oops within the stack frame.

由 JIT（C1 或 C2）发出的 oops 在寄存器中或编译堆栈帧中堆栈上的位置的描述。每个可能执行安全点的代码位置都有一个关联的 GC 映射。GC 知道如何从堆栈中解析帧，如何从帧的 nmethod 请求 GC 映射，以及解压 GC 映射并管理堆栈帧中指示的 oops。

generational garbage collection - 分代垃圾收集

A storage management technique that separates objects expected to be referenced for different lengths of time into different regions of the heap, so that different algorithms can be applied to the collection of those regions.

一种存储管理技术，它将预期在不同时间长度内被引用的对象分离到堆的不同区域中，以便可以对这些区域的集合应用不同的算法。

handle - 句柄

A memory word containing an oop. The word is known to the GC, as a root reference. C/C++ code generally refers to oops indirectly via handles, to enable the GC to find and manage its root set more easily. Whenever C/C++ code blocks in a safepoint, the GC may change any oop stored in a handle. Handles are either ‘local’ (thread-specific, subject to a stack discipline though not necessarily on the thread stack) or global (long-lived and explicitly deallocated). There are a number of handle implementations throughout the VM, and the GC knows about them all.

包含 oop 的内存词。这个词对于 GC 来说是已知的，作为根引用。C/C++ 代码通常通过句柄间接引用 oops，以使 GC 能够更轻松地查找和管理其根集。每当 C/C++ 代码在安全点中阻塞时，GC 可能会更改存储在句柄中的任何 oop。句柄要么是“本地的”（线程特定的，受堆栈规则约束，但不一定在线程堆栈上）或全局（长期存在且显式释放）。整个 VM 中有许多句柄实现，GC 知道所有这些句柄。

hot lock - 高竞争锁

A lock that is highly contended.

高度竞争的锁.

interpreter - 解释器

A VM module which implements method calls by individually executing bytecodes. The interpreter has a limited set of highly stylized stack frame layouts and register usage patterns, which it uses for all method activations. The Hotspot VM generates its own interpreter at start-up time.

通过单独执行字节码来实现方法调用的 VM 模块。解释器有一组有限的高度程式化的堆栈框架布局和寄存器使用模式，它用于所有方法激活。Hotspot VM 在启动时生成自己的解释器。

JIT compilers

An on-line compiler which generates code for an application (or class library) during execution of the application itself. (“JIT” stands for “just in time”.) A JIT compiler may create machine code shortly before the first invocation of a Java method. Hotspot compilers usually allow the interpreter ample time to “warm up” Java methods, by executing them thousands of times. This warm-up period allows a compiler to make better optimization decisions, because it can observe (after initial class loading) a more complete class hierarchy. The compiler can also inspect branch and type profile information gathered by the interpreter.

一个在线编译器，它在应用程序本身的执行过程中为应用程序（或类库）生成代码。（“JIT”代表“及时”。）JIT 编译器可能会在第一次调用 Java 方法之前不久创建机器代码。热点编译器通常允许解释器有足够的时间来“预热”Java 方法，方法是执行它们数千次。这个预热期允许编译器做出更好的优化决策，因为它可以观察（在初始类加载之后）更完整的类层次结构。编译器还可以检查解释器收集的分支和类型配置文件信息。

JNI

The Java Native Interface - a specification and API for how Java code can call out to native C code, and how native C code can call into the Java VM.

Java 本机接口 - 关于 Java 代码如何调用本机 C 代码以及本机 C 代码如何调用 Java VM 的规范和 API

JVM TI - JVM 工具接口

The Java Virtual Machine Tools Interface - a standard specification and API that is used by development and monitoring tools. See JVM TI for more information.

Java 虚拟机工具接口 - 开发和监控工具使用的标准规范和 API。有关更多信息，请参阅JVM TI。

object header - 对象头

Common structure at the beginning of every GC-managed heap object. (Every oop points to an object header.) Includes fundamental information about the heap object’s layout, type, GC state, synchronization state, and identity hash code. Consists of two words. In arrays it is immediately followed by a length field. Note that both Java objects and VM-internal objects have a common object header format.

每个 GC 管理的堆对象开头的公共结构。（每个 oop 都指向一个对象头。）包括关于堆对象的布局、类型、GC 状态、同步状态和身份哈希码的基本信息。由两个词组成。在数组中，它紧跟一个长度字段。请注意，Java 对象和 VM 内部对象都有一个共同的对象头格式。

mark word

The first word of every object header. Usually a set of bitfields including synchronization state and identity hash code. May also be a pointer (with characteristic low bit encoding) to synchronization related information. During GC, may contain GC state bits.

每个对象头的第一个字。通常是一组位域，包括同步状态和身份哈希码。也可以是指向同步相关信息的指针（具有特征性的低位编码）。在 GC 期间，可能包含 GC 状态位。

klass pointer

The second word of every object header. Points to another object (a metaobject) which describes the layout and behavior of the original object. For Java objects, the “klass” contains a C++ style “vtable”.

每个对象头的第二个字。指向另一个对象（元对象），它描述了原始对象的布局和行为。对于 Java 对象，“klass”包含 C++ 风格的“vtable”。

method

A block of executable code which implements some Java bytecodes. It may be a complete Java method, or an ‘OSR’ method. It routinely includes object code for additional methods inlined by the compiler.

实现一些 Java 字节码的可执行代码块。它可能是一个完整的 Java 方法，也可能是一个 OSR 方法。它通常包括编译器内联的其他方法的目标代码。

object promotion - 对象提升

The act of copying an object from one generation to another.

将对象从一代复制到另一代的行为。

old generation - 老年代

A region of the Java object heap that holds object that have remained referenced for a while.

Java 对象堆中的一个区域，用于保存已被引用一段时间的对象。

on-stack replacement - 栈上替换

Also known as ‘OSR’. The process of converting an interpreted (or less optimized) stack frame into a compiled (or more optimized) stack frame. This happens when the interpreter discovers that a method is looping, requests the compiler to generate a special nmethod with an entry point somewhere in the loop (specifically, at a backward branch), and transfers control to that nmethod. A rough inverse to deoptimization.

也称为“OSR”。将解释的（或优化程度较低的）堆栈帧转换为编译的（或优化程度更高的）堆栈帧的过程。当解释器发现一个方法正在循环时，就会发生这种情况，请求编译器生成一个特殊的 nmethod，在循环的某处（特别是在一个反向分支）有一个入口点，并将控制转移到那个 nmethod。去优化的粗略逆。

oop - 对象指针

An object pointer. Specifically, a pointer into the GC-managed heap. (The term is traditional. One ‘o’ may stand for ‘ordinary’.) Implemented as a native machine address, not a handle. Oops may be directly manipulated by compiled or interpreted Java code, because the GC knows about the liveness and location of oops within such code. (See GC map.) Oops can also be directly manipulated by short spans of C/C++ code, but must be kept by such code within handles across every safepoint.

一个对象指针。具体来说，指向 GC 管理的堆的指针。（该术语是传统的。一个“o”可能代表“普通”。）实现为本地机器地址，而不是句柄。Oops 可以由编译或解释的 Java 代码直接操作，因为 GC 知道 oops 在此类代码中的活跃度和位置。（请参阅 GC Map。）Oops 也可以由短跨度的 C/C++ 代码直接操作，但必须由此类代码保存在每个安全点的句柄内。

parallel classloading - 并行类加载

The ability to have multiple classes/type be in the process of being loaded by the same classloader at the same time.

让多个 class/type 同时被同一个类加载器加载的能力。

parallel garbage collection - 并行垃圾回收

A garbage collection algorithm that uses multiple threads of control to perform more efficiently on multi-processor boxes.

一种垃圾收集算法，它使用多个控制线程在多处理器机器上更有效地执行。

permanent generation - 永久代

A region of the address space that holds object allocated by the virtual machine itself, but which is managed by the garbage collector. The permanent generation is mis-named, in that almost all of the objects in it can be collected, though they tend to be referenced for a long time, so they rarely become garbage.

地址空间的一个区域，用于保存由虚拟机本身分配的对象，但由垃圾收集器管理。永久代被错误命名，因为它几乎所有的对象都可以被收集，尽管它们往往会被引用很长时间，所以它们很少成为垃圾。

remembered set

A data structure that records pointers between generations.

记录代间指针的数据结构。

safe point - 安全点

A point during program execution at which all GC roots are known and all heap object contents are consistent. From a global point of view, all threads must block at a safepoint before the GC can run. (As a special case, threads running JNI code can continue to run, because they use only handles. During a safepoint they must block instead of loading the contents of the handle.) From a local point of view, a safepoint is a distinguished point in a block of code where the executing thread may block for the GC. Most call sites qualify as safepoints. There are strong invariants which hold true at every safepoint, which may be disregarded at non-safepoints. Both compiled Java code and C/C++ code be optimized between safepoints, but less so across safepoints. The JIT compiler emits a GC map at each safepoint. C/C++ code in the VM uses stylized macro-based conventions (e.g., TRAPS) to mark potential safepoints.

程序执行期间所有 GC 根都已知且所有堆对象内容一致的点。从全局的角度来看，所有线程都必须在 GC 运行之前在安全点阻塞。（作为一种特殊情况，运行 JNI 代码的线程可以继续运行，因为它们只使用句柄。在安全点期间，它们必须阻塞而不是加载句柄的内容。）从本地的角度来看，安全点是一个特殊的点在执行线程可能因 GC 而阻塞的代码块中。大多数呼叫站点都可以作为安全点。存在在每个安全点都成立的强不变量，在非安全点可能会被忽略。编译的 Java 代码和 C/C++ 代码都在安全点之间进行了优化，但在安全点之间的优化较少。JIT 编译器在每个安全点发出一个 GC 映射。

sea-of-nodes

The high-level intermediate representation in C2. It is an SSA form where both data and control flow are represented with explicit edges between nodes. It differs from forms used in more traditional compilers in that nodes are not bound to a block in a control flow graph. The IR allows nodes to float within the sea (subject to edge constraints) until they are scheduled late in the compilation process.

C2 中的高级中间表示。它是一种 SSA 形式，其中数据和控制流都用节点之间的显式边表示。它不同于更传统的编译器中使用的形式，因为节点不绑定到控制流图中的块。IR 允许节点在海中漂浮（受边缘约束），直到它们被安排在编译过程的后期。

serviceability Agent - 可维护性代理

The Serviceablity Agent is collection of Sun internal code that aids in debugging HotSpot problems. It is also used by several JDK tools - jstack, jmap, jinfo, and jdb. See SA for more information.

可维护性代理是帮助调试 HotSpot 问题的 Sun 内部代码的集合。它也被一些 JDK 工具使用——jstack、jmap、jinfo 和 jdb。有关详细信息，请参阅SA。

stackmap - 栈图

Refers to the StackMapTable attribut e or a particular StackMapFrame in the table.

指的是 StackMapTable 属性 e 或表中的特定 StackMapFrame。

stackMapTable - 栈映射表

An attribute of the Code attribute in a classfile which contains type information used by the new verifier during verification. It consists of an array of StackMapFrames. It is generated automatically by javac as of JDK6.

类文件中 Code 属性的一个属性，其中包含新验证器在验证过程中使用的类型信息。它由一组 StackMapFrames 组成。从 JDK6 开始，它是由 javac 自动生成的。

survivor space - 幸存者空间

A region of the Java object heap used to hold objects. There are usually a pair of survivor spaces, and collection of one is achieved by copying the referenced objects in one survivor space to the other survivor space.

用于保存对象的 Java 对象堆区域。通常有一对 survivor 空间，通过将一个 survivor 空间中引用的对象复制到另一个 survivor 空间来实现一个集合。

在 hotspot VM 中，有两个 survivor 取，分别为 eden1 和 eden2。在垃圾回收触发时，将新生代和1区的存活对象复制到2区，再次触发回收，将新生代和2区的存活对象复制到1区，如此反复，直到部分对象出现对象提升现象—存活时间够久自动升级到老年代，或者伊甸园区空间不够，将部分对象移到老年代。

synchronization - 同步

In general terms this is the coordination of concurrent activities to ensure the safety and liveness properties of those activities. For example, protecting access to shared data by using a lock to guard all code paths to that data.

一般而言，这是对并发活动的协调，以确保这些活动的安全性和活跃性。例如，通过使用锁来保护对共享数据的访问来保护该数据的所有代码路径。

TLAB

Thread-local allocation buffer. Used to allocate heap space quickly without synchronization. Compiled code has a “fast path” of a few instructions which tries to bump a high-water mark in the current thread’s TLAB, successfully allocating an object if the bumped mark falls before a TLAB-specific limit address.

线程本地分配缓冲区。用于在不同步的情况下快速分配堆空间。编译后的代码有一些指令的“快速路径”，这些指令试图在当前线程的 TLAB 中达到高水位标记，如果撞击标记落在 TLAB 特定的限制地址之前，则成功分配对象。

uncommon trap - 不寻常的陷阱

When code generated by C2 reverts back to the interpreter for further execution. C2 typically compiles for the common case, allowing it to focus on optimization of frequently executed paths. For example, C2 inserts an uncommon trap in generated code when a class that is uninitialized at compile time requires run time initialization.

当 C2 生成的代码返回到解释器以进一步执行时。C2 通常针对常见情况进行编译，使其能够专注于优化频繁执行的路径。例如，当编译时未初始化的类需要运行时初始化时，C2 会在生成的代码中插入一个不常见的陷阱。

verifier - 验证器

The software code in the VM which performs bytecode verification.

VM 中执行字节码验证的软件代码。

VM operations - 虚拟机操作

Operations in the VM that can be requested by Java threads, but which must be executed, in serial fashion by a specific thread known as the VM thread. These operations are often synchronous, in that the requester will block until the VM thread has completed the operation. Many of these operations also require that the VM be brought to a safepoint before the operation can be performed - a garbage collection request is a simple example.

可以由 Java 线程请求但必须由称为 VM 线程的特定线程以串行方式执行的 VM 中的操作。这些操作通常是同步的，因为请求者将阻塞直到 VM 线程完成操作。其中许多操作还要求在执行操作之前将 VM 带到安全点——垃圾收集请求就是一个简单的例子。

write barrier - 写屏障

Code that is executed on every oop store. For example, to maintain a remembered set.

在每个 oop 存储上执行的代码。例如，维护一个可存储的集合。