Durante un diagnóstico de rendimiento en una aplicación Java, se empleó el comando jmap para generar un volcado de la memoria heap. Posteriormente, al analizarlo con la herramienta MAT (Memory Analyzer Tool), se identificó una cantidad elevada de objetos java.lang.ref.Finalizer. El informe de sospechas de fugas (Leak Suspects) mostró un consumo significativo de memoria, lo que planteó la posibilidad de una fuga de memoria (memory leak).

Investigación y referencias clave

Se revisaron diversas fuentes técnicas para entender el comportamiento de finalize(). Entre los temas explorados se encuentran: desbordamientos de memoria causados por Finalizer, la posible descontinuación de este método en Java, problemas de alta utilización de memoria en java.lang.ref.FinalizerReference, y casos donde objetos como SocksSocketImpl o FileInputStream contribuyen a ciclos completos de recolección de basura (Full GC).

El rol de finalize() como último recurso

Ciertas clases, como FileInputStream o SocksSocketImpl, implementan el método finalize() de la clase Object; a estos se les denomina objetos finalizables. El siguiente ejemplo ilustra una implementación típica, aunque con una lógica simplificada:

public class RecursoFinalizable {
    public static void ejecutar() {
        for (int iteracion = 0; ; iteracion++) {
            new RecursoFinalizable();
            // Lógica adicional omitida
        }
    }

    @Override
    protected void finalize() {
        // Implementación que evita optimizaciones del JVM
        System.out.println("Proceso de finalización");
    }
}

Es crucial notar que si finalize() estuviera vacío, la JVM podría ignorarlo. Por tanto, se provee una implementación mínima para que el método sea efectivo. En el mecanismo de recolección de basura de la JVM, los objetos finalizables se asocian a un objeto Finalizer, el cual se encola en java.lang.ref.Finalizer.ReferenceQueue, una lista doblemente enlazada. Debido a estas referencias, el GC no puede recolectar los objetos finalizables inicialmente. Si la región Eden se llena y el Survivor no tiene espacio, estos objetos pueden promoverse directamente al Old Generation.

El hilo FinalizerThread, visible mediante jstack, procesa esta cola. Tras invocar finalize(), se desvincula el objeto finalizable del Finalizer, quedando ambos sin referencias y listos para ser recolectados en el siguiente ciclo de GC.

Inicialización del FinalizerThread:

static {
    ThreadGroup grupoActual = Thread.currentThread().getThreadGroup();
    ThreadGroup grupoPadre;
    while ((grupoPadre = grupoActual.getParent()) != null) {
        grupoActual = grupoPadre;
    }
    Thread hiloFinalizador = new FinalizerThread(grupoActual);
    hiloFinalizador.setPriority(Thread.NORM_PRIORITY);
    hiloFinalizador.setDaemon(true);
    hiloFinalizador.start();
}

El método run() del hilo extrae objetos de la cola:

public void run() {
    if (activo) return;
    while (!VM.isBooted()) {
        try { VM.awaitBooted(); } catch (InterruptedException e) { }
    }
    final JavaLangAccess acceso = SharedSecrets.getJavaLangAccess();
    activo = true;
    while (true) {
        try {
            Finalizer f = (Finalizer) cola.remover();
            f.ejecutarFinalizador(acceso);
        } catch (InterruptedException e) { }
    }
}

Finalmente, ejecutarFinalizador() invoca finalize() y limpia la referencia:

private void ejecutarFinalizador(JavaLangAccess acceso) {
    synchronized (this) {
        if (yaFinalizado()) return;
        remover();
    }
    try {
        Object objetivo = this.get();
        if (objetivo != null && !(objetivo instanceof java.lang.Enum)) {
            acceso.invocarFinalize(objetivo);
            objetivo = null; // Liberar referencia para evitar retención
        }
    } catch (Throwable e) { }
    super.clear();
}

Dado que el FinalizerThread tiene menor prioridad que el hilo principal, su velocidad de procesamiento puede ser insuficeinte ante una generación masiva de objetos. Esto puede llevar a la acumulación de descriptores de archivos (file descriptors), provocando errores como "Too many open files in system".

Propósito del mecanismo de finalización

La finalidad principal de finalize() es liberar recursos (como sockets o archivos) antes de que el objeto sea eliminado de la memoria. Actúa como un mecanismo de seguridad (safety net) para operaciones de limpieza, especialmente cuendo otros métodos de liberación fallan.

En resumen, aunque el mecanismo de finalización está diseñado para garantizar la liberación de recursos, su uso excesivo o incorrecto puede causar fugas de memoria o excepciones OutOfMemoryError. Por tanto, se desaconseja su uso en aplicaciones críticas debido a su falta de control y rendimiento impreedcible.