Una breve introducción a los detalles de recuperación de memoria de la máquina virtual Java (HotSpot)

¡Acostúmbrate a escribir juntos! Este es el octavo día de mi participación en el "Nuggets Daily New Plan · April Update Challenge", haz clic para ver los detalles del evento .

La forma de recuperar automáticamente la memoria JVM y los algoritmos comunes de recolección de elementos no utilizados se han presentado anteriormente . Ahora las aplicaciones de Java son cada vez más grandes. El tamaño del área de método por sí solo suele ser de cientos de gigabytes, y las clases y constantes que contiene son incluso más grandes que la arena del Ganges. Por lo tanto, cuando la máquina virtual Java implementa estos algoritmos, se debe dar estricta consideración a la eficiencia de ejecución de los algoritmos, para asegurar el funcionamiento eficiente de la máquina virtual.

Hoy, analicemos cómo la máquina virtual HotSpot inicia el reciclaje de memoria, cómo acelerar el reciclaje de memoria y cómo garantizar la corrección del reciclaje.

¿Cómo iniciar la recuperación de memoria?

La JVM principal actual utiliza el algoritmo de análisis de accesibilidad para encontrar objetos inactivos a través de la enumeración del nodo raíz .

Los nodos fijos disponibles GC Rootsse encuentran principalmente en referencias globales (como constantes o propiedades estáticas de clase) y contextos de ejecución (como tablas de variables locales en marcos de pila). Aunque el objetivo es claro, no es fácil hacer que el proceso de búsqueda sea eficiente. Cosas, tales como clases, constantes, etc., deben consumir mucho tiempo para verificar las referencias que se originan aquí una por una.

Actualmente, todos los recopiladores deben suspender los subprocesos de los usuarios durante el paso de enumeración raíz , por lo que no hay duda de que la enumeración raíz enfrentará un problema similar al de la desfragmentación mencionada anteriormente.

Aunque el proceso de búsqueda de la cadena de referencia, que lleva más tiempo para el algoritmo de análisis de accesibilidad, puede realizarse simultáneamente con el subproceso del usuario , la enumeración del nodo raíz siempre debe realizarse en una instantánea que pueda garantizar la coherencia .

Esta es una de las razones importantes por las que el proceso de recolección de elementos no utilizados debe pausar todos los subprocesos de usuario Incluso los recopiladores como CMS, G1, ZGC, etc., que afirman tener un tiempo de pausa controlable, o (casi) ninguna pausa, deben enumerar el nodo raíz para detener.

Una nota sobre la consistencia

Durante todo el período de enumeración, el subsistema de ejecución parece estar congelado en un momento determinado y no habrá ninguna situación en la que la relación de referencia de objetos de la colección de nodos raíz siga cambiando durante el proceso de análisis . , no se puede garantizar la precisión del resultado del análisis.

¿Cómo acelerar la recuperación de memoria?

La solución principal es optimizar la búsqueda de GC Roots y el análisis de accesibilidad paralelo .

Optimice la búsqueda de GC Roots

Dado que las máquinas virtuales Java convencionales actuales utilizan una recolección de elementos no utilizados precisa , cuando se detiene el subproceso del usuario, no es necesario verificar todos los contextos de ejecución y las ubicaciones de referencia globales sin perder el ritmo. La máquina virtual debe tener una forma de obtener directamente Dónde almacenar referencias de objetos

Solución: utilice un punto seguro durante la ejecución del programa

En la solución de HotSpot, se utiliza un conjunto de estructuras de datos llamado OopMap para este propósito. Una vez que se completa la acción de carga de clases, HotSpot calculará qué tipo de datos se encuentran en qué desplazamiento en el objeto y, durante el proceso de compilación justo a tiempo , también registrará qué posiciones en la pila y registros son referencias en ubicaciones específicas. .

De esta forma, el recolector puede conocer directamente la información al momento de escanear, y no necesita GC Rootsiniciar la búsqueda desde el área de métodos sin ninguna omisión.

在OopMap的协助下，HotSpot可以快速准确地完成GC Roots枚举，但一个很现实的问题随之而来： 可能导致引用关系变化，或者说导致OopMap内容变化的指令非常多，如果为每一条指令都生成对应的OopMap，那将会需要大量的额外存储空间。

实际上HotSpot也的确没有为每条指令都生成OopMap，只是在“特定的位置”记录了这些信息，这些位置被称为安全点（Safepoint） 。 有了安全点的设定，也就决定了用户程序执行时并非在代码指令流的任意位置都能够停顿下来开始垃圾收集，而是强制要求必须执行到达安全点后才能够暂停。

因此，安全点的选定既不能太少以至于让收集器等待时间过长，也不能太过频繁以至于过分增大运行时的内存负荷。

安全点的选取

安全点位置的选取基本上是以“是否具有让程序长时间执行的特征”为标准进行选定的，因为每条指令执行的时间都非常短暂，程序不太可能因为指令流长度太长这样的原因而长时间执行， “长时间执行”的最明显特征就是指令序列的复用， 例如方法调用、 循环跳转、 异常跳转等都属于指令序列复用， 所以只有具有这些功能的指令才会产生安全点。

对于安全点，另外一个需要考虑的问题是，如何在垃圾收集发生时让所有线程（这里其实不包括执行JNI调用的线程）都跑到最近的安全点， 然后停顿下来。

这里有两种方案可供选择： 抢先式中断（Preemptive Suspension） 和主动式中断（Voluntary Suspension） 。

• 抢先式中断不需要线程的执行代码主动去配合，在垃圾收集发生时，系统首先把所有用户线程全部中断，如果发现有用户线程中断的地方不在安全点上， 就恢复这条线程执行， 让它一会再重新中断， 直到跑到安全点上。 现在几乎没有虚拟机实现采用抢先式中断来暂停线程响应GC事件。

• 主动式中断的思想是当垃圾收集需要中断线程的时候，不直接对线程操作，仅仅简单地设置一个标志位， 各个线程执行过程时会不停地主动去轮询这个标志， 一旦发现中断标志为真时就自己在最近的安全点上主动中断挂起。 轮询标志的地方和安全点是重合的，另外还要加上所有创建对象和其他需要在Java堆上分配内存的地方，这是为了检查是否即将要发生垃圾收集，避免没有足够内存分配新对象。由于轮询操作在代码中会频繁出现，这要求它必须足够高效。HotSpot使用内存保护陷阱的方式，把轮询操作精简至只有一条汇编指令的程度。

解决方案：程序不执行时采用安全区域

使用安全点的设计似乎已经完美解决如何停顿用户线程，让虚拟机进入垃圾回收状态的问题了，但实际情况却并不一定。安全点机制保证了程序执行时， 在不太长的时间内就会遇到可进入垃圾收集过程的安全点。

但是，程序“不执行”的时候呢？ 所谓的程序不执行就是没有分配处理器时间，典型的场景便是用户线程处于Sleep状态或者Blocked状态，这时候线程无法响应虚拟机的中断请求，不能再走到安全的地方去中断挂起自己，虚拟机也显然不可能持续等待线程重新被激活分配处理器时间。对于这种情况，就必须引入安全区域（Safe Region） 来解决。

安全区域是指能够确保在某一段代码片段之中，引用关系不会发生变化，因此，在这个区域中任意地方开始垃圾收集都是安全的。 我们也可以把安全区域看作被扩展拉伸了的安全点。

当用户线程执行到安全区域里面的代码时，首先会标识自己已经进入了安全区域，那样当这段时间里虚拟机要发起垃圾收集时就不必去管这些已声明自己在安全区域内的线程了。

当线程要离开安全区域时，它要检查虚拟机是否已经完成了根节点枚举（或者垃圾收集过程中其他需要暂停用户线程的阶段）。

• 如果完成了，那线程就当作没事发生过，继续执行；
• 否则，它就必须一直等待，直到收到可以离开安全区域的信号为止。

如何保证内存回收正确性?

解决对象跨代引用问题：记忆集与卡表

为解决对象跨代引用所带来的问题， 垃圾收集器在新生代中建立了名为记忆集（Remembered Set） 的数据结构， 用以避免把整个老年代加进GC Roots扫描范围。

事实上并不只是新生代、 老年代之间才有跨代引用的问题， 所有涉及部分区域收集（Partial GC） 行为的垃圾收集器， 典型的如G1、 ZGC和Shenandoah收集器， 都会面临相同的问题。

记忆集是一种用于记录从非收集区域指向收集区域的指针集合的抽象数据结构。

如果我们不考虑效率和成本的话，最简单的实现可以用非收集区域中所有含跨代引用的对象数组来实现这个数据结构。这种记录全部含跨代引用对象的实现方案，无论是空间占用还是维护成本都相当高昂。伪代码如下所示：

class RememberedSet {
    Object[] set[OBJECT_INTERGENERATIONAL_REFERENCE_SIZE];
}
复制代码

而在垃圾收集的场景中，收集器只需要通过记忆集判断出某一块非收集区域是否存在有指向了收集区域的指针就可以了，并不需要了解这些跨代指针的全部细节。

那设计者在实现记忆集的时候， 便可以选择更为粗犷的记录粒度来节省记忆集的存储和维护成本，下面列举了一些可供选择（当然也可以选择这个范围以外的） 的记录精度：

• 字长精度： 每个记录精确到一个机器字长（就是处理器的寻址位数， 如常见的32位或64位，这个精度决定了机器访问物理内存地址的指针长度），该字包含跨代指针。
• 对象精度： 每个记录精确到一个对象，该对象里有字段含有跨代指针。
• 卡精度： 每个记录精确到一块内存区域， 该区域内有对象含有跨代指针

其中， 第三种“卡精度”所指的是用一种称为“卡表”（Card Table） 的方式去实现记忆集， 这也是目前最常用的一种记忆集实现形式。

记忆集与卡表的区别：

记忆集其实是一种“抽象”的数据结构， 抽象的意思是只定义了记忆集的行为意图， 并没有定义其行为的具体实现。

卡表就是记忆集的一种具体实现， 它定义了记忆集的记录精度、 与堆内存的映射关系等。

卡表最简单的形式可以只是一个字节数组， 而HotSpot虚拟机确实也是这样做的。 以下这行代码是HotSpot默认的卡表标记逻辑。

CARD_TABLE [this address >> 9] = 0;
复制代码

字节数组CARD_TABLE的每一个元素都对应着其标识的内存区域中一块特定大小的内存块， 这个内存块被称作“卡页”（Card Page） 。

一般来说， 卡页大小都是以2的N次幂的字节数，通过上面代码可以看出HotSpot中使用的卡页是2的9次幂， 即512字节（地址右移9位， 相当于用地址除以512）。

那如果卡表标识内存区域的起始地址是0x0000的话，数组CARD_TABLE的第0、 1、 2号元素，分别对应了地址范围为0x0000～0x01FF、 0x0200～0x03FF、 0x0400～0x05FF的卡页内存块， 如下图所示。

一个卡页的内存中通常包含不止一个对象，只要卡页内有一个（或更多） 对象的字段存在着跨代指针， 那就将对应卡表的数组元素的值标识为1， 称为这个元素变脏（Dirty） ， 没有则标识为0。 在垃圾收集发生时，只要筛选出卡表中变脏的元素， 就能轻易得出哪些卡页内存块中包含跨代指针， 把它们加入GC Roots中一并扫描。

卡表元素如何维护：写屏障

我们已经解决了如何使用记忆集来缩减GC Roots扫描范围的问题，但还没有解决卡表元素如何维护的问题，例如它们何时变脏、谁来把它们变脏等。

卡表元素何时变脏的答案是很明确的——有其他分代区域中对象引用了本区域对象时， 其对应的卡表元素就应该变脏， 变脏时间点原则上应该发生在引用类型字段赋值的那一刻。

但问题是如何变脏，即如何在对象赋值的那一刻去更新维护卡表呢？

• 假如是解释执行的字节码，那相对好处理，虚拟机负责每条字节码指令的执行，有充分的介入空间；
• 但在编译执行的场景中呢？经过即时编译后的代码已经是纯粹的机器指令流了， 这就必须找到一个在机器码层面的手段，把维护卡表的动作放到每一个赋值操作之中。

在HotSpot虚拟机里是通过写屏障（Write Barrier） 技术维护卡表状态的。

写屏障可以看作在虚拟机层面对“引用类型字段赋值”这个动作的AOP切面，在引用对象赋值时会产生一个环形（Around）通知， 供程序执行额外的动作， 也就是说赋值的前后都在写屏障的覆盖范畴内。

在赋值前的部分的写屏障叫作写前屏障（Pre-Write Barrier）， 在赋值后的则叫作写后屏障（Post-Write Barrier） 。

HotSpot虚拟机的许多收集器中都有使用到写屏障， 但直至G1收集器出现之前，其他收集器都只用到了写后屏障。

写后屏障更新卡表代码如下所示：

void oop_field_store(oop* field, oop new_value) {
    // 引用字段赋值操作
    *field = new_value;
    // 写后屏障， 在这里完成卡表状态更新
    post_write_barrier(field, new_value);
}
复制代码

写屏障存在的一些问题

应用写屏障后，虚拟机就会为所有赋值操作生成相应的指令，一旦收集器在写屏障中增加了更新卡表操作，无论更新的是不是老年代对新生代对象的引用，每次只要对引用进行更新，就会产生额外的开销，不过这个开销与Minor GC时扫描整个老年代的代价相比还是低得多的。

除了写屏障的开销外，卡表在高并发场景下还面临着“伪共享”（False Sharing） 问题。 伪共享是处理并发底层细节时一种经常需要考虑的问题，现代中央处理器的缓存系统中是以缓存行（Cache Line）为单位存储的， 当多线程修改互相独立的变量时，如果这些变量恰好共享同一个缓存行，就会彼此影响（写回、无效化或者同步）而导致性能降低，这就是伪共享问题。

假设处理器的缓存行大小为64字节， 由于一个卡表元素占1个字节， 64个卡表元素将共享同一个缓存行。

这64个卡表元素对应的卡页总的内存为32KB（64×512字节） ，也就是说如果不同线程更新的对象正好处于这32KB的内存区域内， 就会导致更新卡表时正好写入同一个缓存行而影响性能。

为了避免伪共享问题，一种简单的解决方案是不采用无条件的写屏障，而是先检查卡表标记， 只有当该卡表元素未被标记过时才将其标记为变脏。

将卡表更新的逻辑变为以下代码所示：

if (CARD_TABLE [this address >> 9] != 0)
    CARD_TABLE [this address >> 9] = 0
复制代码

在JDK 7之后，HotSpot虚拟机增加了一个新的参数-XX:+UseCondCardMark，用来决定是否开启卡表更新的条件判断。开启会增加一次额外判断的开销，但能够避免伪共享问题，两者各有性能损耗，是否打开要根据应用实际运行情况来进行测试权衡。

并发的可达性分析

当前主流编程语言的垃圾收集器基本上都是依靠可达性分析算法来判定对象是否存活的，可达性分析算法理论上要求全过程都基于一个能保障一致性的快照中才能够进行分析，这意味着必须全程冻结用户线程的运行。

在根节点枚举这个步骤中， 由于GC Roots相比起整个Java堆中全部的对象毕竟还算是极少数，且在各种优化技巧（如OopMap）的加持下，它带来的停顿已经是非常短暂且相对固定（不随堆容量而增长）的了。

可从GC Roots再继续往下遍历对象图，这一步骤的停顿时间就必定会与Java堆容量直接成正比例关系了：堆越大， 存储的对象越多，对象图结构越复杂，要标记更多对象而产生的停顿时间自然就更长。

要知道包含“标记”阶段是所有追踪式垃圾收集算法的共同特征， 如果这个阶段会随着堆变大而等比例增加停顿时间， 其影响就会波及几乎所有的垃圾收集器，同理可知，如果能够削减这部分停顿时间的话， 那收益也将会是系统性的。

三色标记工具

想解决或者降低用户线程的停顿，就要先搞清楚为什么必须在一个能保障一致性的快照上才能进行对象图的遍历？

为了能解释清楚这个问题， 我们引入三色标记（Tri-color Marking）作为工具来辅助推导， 把遍历对象图过程中遇到的对象， 按照“是否访问过”这个条件标记成以下三种颜色：

• 白色： 表示对象尚未被垃圾收集器访问过。显然在可达性分析刚刚开始的阶段，所有的对象都是白色的，若在分析结束的阶段， 仍然是白色的对象， 即代表不可达。
• 黑色： 表示对象已经被垃圾收集器访问过，且这个对象的所有引用都已经扫描过。 黑色的对象代表已经扫描过， 它是安全存活的， 如果有其他对象引用指向了黑色对象， 无须重新扫描一遍。黑色对象不可能直接（不经过灰色对象） 指向某个白色对象。
• 灰色： 表示对象已经被垃圾收集器访问过，但这个对象上至少存在一个引用还没有被扫描。

关于可达性分析的扫描过程，把它看作对象图上一股以灰色为波峰的波纹从黑向白推进的过程， 如果用户线程此时是冻结的，只有收集器线程在工作， 那不会有任何问题。

但如果用户线程与收集器是并发工作呢？

用户线程与收集器是并发工作存在的问题

收集器在对象图上标记颜色，同时用户线程在修改引用关系---即修改对象图的结构， 这样可能出现两种后果。

• 一种是把原本消亡的对象错误标记为存活，这不是好事， 但其实是可以容忍的， 只不过产生了一点逃过本次收集的浮动垃圾而已， 下次收集清理掉就好。
• 另一种是把原本存活的对象错误标记为已消亡，这就是非常致命的后果了， 程序肯定会因此发生错误。

下面演示了这样的致命错误具体是如何产生的：

如果用户线程此时是冻结的， 只有收集器线程在工作， 那不会有任何问题。

但如果用户线程与收集器是并发工作出现如下两种情况，将会导致对象消失。

Wilson于1994年在理论上证明了， 当且仅当以下两个条件同时满足时， 会产生“对象消失”的问题， 即原本应该是黑色的对象被误标为白色：

• 赋值器插入了一条或多条从黑色对象到白色对象的新引用；
• 赋值器删除了全部从灰色对象到该白色对象的直接或间接引用。

如何保证内存回收正确性?

我们要解决并发扫描时的对象消失问题， 只需破坏上面这两个条件的任意一个即可。 由此分别产生了两种解决方案： 增量更新（Incremental Update） 和原始快照（Snapshot At The Beginning，SATB） 。

• 增量更新要破坏的是第一个条件，当黑色对象插入新的指向白色对象的引用关系时，就将这个新插入的引用记录下来，等并发扫描结束之后，再将这些记录过的引用关系中的黑色对象为根， 重新扫描一次。 这可以简化理解为， 黑色对象一旦新插入了指向白色对象的引用之后， 它就变回灰色对象了。
• 原始快照要破坏的是第二个条件，当灰色对象要删除指向白色对象的引用关系时， 就将这个要删除的引用记录下来， 在并发扫描结束之后，再将这些记录过的引用关系中的灰色对象为根，重新扫描一次。这也可以简化理解为，无论引用关系删除与否， 都会按照刚刚开始扫描那一刻的对象图快照来进行搜索。

以上无论是对引用关系记录的插入还是删除， 虚拟机的记录操作都是通过写屏障实现的。

在HotSpot虚拟机中， 增量更新和原始快照这两种解决方案都有实际应用， 譬如， CMS是基于增量更新来做并发标记的， G1、 Shenandoah则是用原始快照来实现。

总结

本文简要概述了HotSpot虚拟机的内存回收一些细节。首先，谈到了当前主流的JVM都是采用可达性分析算法通过根节点枚举来找到已经死去的对象，发起内存回收。同时，也存在如下问题：

• 现在Java应用越做越庞大，光是方法区的大小就常有数百上千兆
• 所有收集器在根节点枚举这一步骤时都是必须暂停用户线程的
• 从GC Roots再继续往下遍历对象图，这一步骤的停顿时间就必定会与Java堆容量直接成正比例关系了：堆越大，存储的对象越多，对象图结构越复杂，要标记更多对象而产生的停顿时间自然就更长

因此，采用优化GC Roots的查找和并行可达性分析这两种方式来减少停顿时间，加速内存的回收。

第一，通过采用安全点和安全区域的方式来优化GC Roots的查找。通过记忆集与卡表来解决跨代引用的问题。同时，提到了通过写屏障来维护卡表的元素。同时，还提到了写屏障存在的一些问题：写屏障会带来额外开销以及伪共享问题。

En segundo lugar, a través del trabajo simultáneo de subprocesos de usuarios y recopiladores, se logra un análisis de accesibilidad paralelo . Comprenda el proceso de atravesar el gráfico de objetos con la herramienta de marcador de tres colores. Al mismo tiempo, se menciona que el trabajo simultáneo del subproceso de usuario y el recopilador hará que el objeto desaparezca , y también se mencionan las dos soluciones de actualización incremental e instantánea original para resolver este problema.