¿Cómo funciona Java Garbage Collection con referencias circulares?

Según tengo entendido, la recolección de basura en Java limpia algunos objetos si nada más está 'apuntando' a ese objeto.

Mi pregunta es, qué pasa si tenemos algo como esto:

class Node {
    public object value;
    public Node next;
    public Node(object o, Node n) { value = 0; next = n;}
}

//...some code
{
    Node a = new Node("a", null), 
         b = new Node("b", a), 
         c = new Node("c", b);
    a.next = c;
} //end of scope
//...other code

a, bY cdebe ser recogido de basura, pero todos ellos están siendo referenciado por otros objetos.

¿Cómo trata la recolección de basura Java con esto? (¿o es simplemente una pérdida de memoria?)

El GC de Java considera que los objetos son "basura" si no son accesibles a través de una cadena que comienza en una raíz de recolección de basura, por lo que estos objetos serán recolectados. Aunque los objetos pueden señalarse entre sí para formar un ciclo, siguen siendo basura si están separados de la raíz.

Consulte la sección sobre objetos inalcanzables en el Apéndice A: La verdad sobre la recolección de basura en el rendimiento de la plataforma Java: estrategias y tácticas para obtener detalles sangrientos.

sí ¡El recolector de basura Java maneja la referencia circular!

How?

Hay objetos especiales llamados raíces de recolección de basura (raíces GC). Estos son siempre accesibles y también lo es cualquier objeto que los tenga en su propia raíz.

Una aplicación Java simple tiene las siguientes raíces GC:

1. Variables locales en el método principal.
2. El hilo principal
3. Variables estáticas de la clase principal.

Para determinar qué objetos ya no están en uso, la JVM ejecuta de manera intermitente lo que se llama muy bien un algoritmo de marcado y barrido . Funciona de la siguiente manera

1. El algoritmo atraviesa todas las referencias de objetos, comenzando con las raíces del GC, y marca cada objeto encontrado como vivo.
2. Se recupera toda la memoria de almacenamiento dinámico que no está ocupada por objetos marcados. Simplemente está marcado como libre, esencialmente libre de objetos no utilizados.

Por lo tanto, si no se puede acceder a ningún objeto desde las raíces del GC (incluso si es autorreferenciado o cíclico), estará sujeto a la recolección de basura.

Por supuesto, a veces esto puede conducir a una pérdida de memoria si el programador olvida desreferenciar un objeto.

Fuente: Java Memory Management

Un recolector de basura comienza desde algún conjunto "raíz" de lugares que siempre se consideran "accesibles", como los registros de la CPU, la pila y las variables globales. Funciona encontrando cualquier puntero en esas áreas, y encontrando recursivamente todo lo que señalan. Una vez que se encuentra todo eso, todo lo demás es basura.

Hay, por supuesto, bastantes variaciones, principalmente por el bien de la velocidad. Por ejemplo, la mayoría de los recolectores de basura modernos son "generacionales", lo que significa que dividen los objetos en generaciones, y a medida que un objeto envejece, el recolector de basura se alarga cada vez más entre las veces que intenta averiguar si ese objeto aún es válido o no. - Simplemente comienza a suponer que si ha vivido mucho tiempo, es muy probable que continúe viviendo aún más.

No obstante, la idea básica sigue siendo la misma: todo se basa en comenzar a partir de un conjunto raíz de cosas que da por sentado que aún se podrían usar, y luego perseguir todos los punteros para encontrar qué más podría estar en uso.

Interesante aparte: muchas personas pueden sorprenderse a menudo por el grado de similitud entre esta parte de un recolector de basura y el código para ordenar objetos para cosas como llamadas a procedimientos remotos. En cada caso, está comenzando desde algún conjunto raíz de objetos y persiguiendo punteros para encontrar todos los otros objetos a los que se refieren ...

Estás en lo correcto. La forma específica de recolección de basura que describe se denomina " recuento de referencias ". La forma en que funciona (conceptualmente, al menos, las implementaciones más modernas de conteo de referencias se implementan de manera bastante diferente) en el caso más simple, se ve así:

• cada vez que se agrega una referencia a un objeto (por ejemplo, se asigna a una variable o un campo, se pasa al método, etc.), su recuento de referencias aumenta en 1
• cada vez que se elimina una referencia a un objeto (el método regresa, la variable queda fuera del alcance, el campo se reasigna a un objeto diferente o el objeto que contiene el campo se recolecta basura), el recuento de referencias se reduce en 1
• tan pronto como el recuento de referencias llegue a 0, no habrá más referencias al objeto, lo que significa que ya nadie puede usarlo, por lo tanto, es basura y se puede recolectar

Y esta estrategia simple tiene exactamente el problema que usted describe: si A hace referencia a B y B hace referencia a A, entonces sus dos recuentos de referencia nunca pueden ser inferiores a 1, lo que significa que nunca se recopilarán.

Hay cuatro formas de lidiar con este problema:

1. Ignoralo. Si tiene suficiente memoria, sus ciclos son pequeños e infrecuentes y su tiempo de ejecución es corto, tal vez pueda salirse con la suya simplemente no recolectando ciclos. Piense en un intérprete de script de shell: los scripts de shell normalmente solo se ejecutan durante unos segundos y no asignan mucha memoria.
2. Combine su recolector de basura de conteo de referencia con otro recolector de basura que no tenga problemas con los ciclos. CPython hace esto, por ejemplo: el recolector de basura principal en CPython es un recolector de conteo de referencia, pero de vez en cuando se ejecuta un recolector de basura de rastreo para recolectar los ciclos.
3. Detecta los ciclos. Desafortunadamente, detectar ciclos en un gráfico es una operación bastante costosa. En particular, requiere casi la misma sobrecarga que requeriría un recopilador de rastreo, por lo que podría usar uno de esos.
4. No implemente el algoritmo de la manera ingenua que usted y yo haríamos: desde la década de 1970, se han desarrollado múltiples algoritmos bastante interesantes que combinan la detección del ciclo y el recuento de referencias en una sola operación de una manera inteligente que es significativamente más barata que cualquiera de ellos. tanto por separado como haciendo un colector de rastreo.

Por cierto, la otra forma importante de implementar un recolector de basura (y ya lo he insinuado un par de veces más arriba) es el rastreo . Un colector de rastreo se basa en el concepto de accesibilidad . Comienza con un conjunto raíz que sabe que siempre es accesible (constantes globales, por ejemplo, o la Objectclase, el alcance léxico actual, el marco de pila actual) y desde allí rastrea todos los objetos a los que se puede acceder desde el conjunto raíz, luego todos los objetos a los que se puede acceder desde los objetos accesibles desde el conjunto raíz y así sucesivamente, hasta que tenga el cierre transitivo. Todo lo que no está en ese cierre es basura.

Como un ciclo solo es accesible dentro de sí mismo, pero no es accesible desde el conjunto raíz, se recopilará.

Los GC de Java en realidad no se comportan como usted describe. Es más exacto decir que comienzan a partir de un conjunto base de objetos, frecuentemente llamados "raíces GC", y recolectarán cualquier objeto que no pueda ser alcanzado desde una raíz.
Las raíces de GC incluyen cosas como:

• variables estáticas
• variables locales (incluidas todas las referencias 'this' aplicables) actualmente en la pila de un hilo en ejecución

Entonces, en su caso, una vez que las variables locales a, byc salen del alcance al final de su método, no hay más raíces de GC que contengan, directa o indirectamente, una referencia a cualquiera de sus tres nodos, y serán elegibles para la recolección de basura.

El enlace de TofuBeer tiene más detalles si lo desea.

Este artículo (ya no está disponible) profundiza sobre el recolector de basura (conceptualmente ... hay varias implementaciones). La parte relevante de su publicación es "A.3.4 inalcanzable":

A.3.4 Inaccesible Un objeto entra en un estado inalcanzable cuando no existen más referencias fuertes a él. Cuando un objeto es inalcanzable, es un candidato para la colección. Tenga en cuenta la redacción: el hecho de que un objeto sea candidato para la recolección no significa que se recolecte de inmediato. La JVM es libre de retrasar la recopilación hasta que haya una necesidad inmediata de que el objeto consuma la memoria.

La recolección de basura generalmente no significa "limpiar algún objeto si nada más está 'apuntando' a ese objeto" (eso es contar las referencias). Recolección de basura significa aproximadamente encontrar objetos a los que no se puede llegar desde el programa.

Entonces, en su ejemplo, después de que a, byc salgan del alcance, el GC puede recopilarlos, ya que ya no puede acceder a estos objetos.

Bill respondió tu pregunta directamente. Como dijo Amnon, su definición de recolección de basura es solo un recuento de referencias. Solo quería agregar que incluso los algoritmos muy simples como marcar y barrer y copiar colecciones manejan fácilmente referencias circulares. Por lo tanto, no hay nada mágico al respecto!