Memoria y recolector de basura en Java: qué sucede realmente bajo el capó

Cómo gestiona Java la memoria: no solo «recolección de basura»

Muchos desarrolladores que migran a Java desde C++ o Python primero se alegran: «¡Genial, no necesito pensar en fugas de memoria!». Y luego reciben un OutOfMemoryError en el momento más inoportuno y se dan cuenta de que la gestión de memoria en Java requiere un conocimiento profundo. Hoy miraremos bajo el capó de la JVM y analizaremos cómo funcionan realmente la memoria y el recolector de basura en Java.

Este artículo será útil tanto para principiantes que quieran entender el Java memory model, como para desarrolladores experimentados que busquen formas de optimizar el garbage collection Java. ¡Allá vamos!

Cómo está organizada la memoria en Java: heap, stack y Metaspace

Antes de hablar sobre el recolector de basura Java, debemos entender dónde «viven» exactamente sus objetos. La JVM divide la memoria en varias áreas clave:

\n
• Heap (montón) — aquí se almacenan todos los objetos creados. Es el campo de trabajo principal del garbage collection Java.
\n
• Stack (pila) — almacena tipos primitivos y referencias a objetos en el heap. Cada hilo tiene su propia pila.
\n
• Metaspace — reemplazó a PermGen en Java 8, almacena metadatos de clases.
\n
• Code Cache — código compilado por el compilador JIT.
\n

Aquí hay un ejemplo simple que muestra dónde van los datos:

public class MemoryDemo {\n    public static void main(String[] args) {\n        int number = 42;                    // Primitivo — en la pila\n        String text = "Hello";              // Referencia en la pila, objeto en el montón\n        List<String> list = new ArrayList<>(); // Referencia en la pila, lista en el montón\n        list.add("Java");                   // La cadena "Java" — también en el montón\n    }\n}\n

Punto clave: todos los objetos creados con new van al heap Java. Es esta área la que «vigila» el recolector de basura en Java.

Por qué el recolector de basura no es un enemigo, sino un amigo (si entiendes su lógica)

Muchos desarrolladores temen al Java GC por las pausas «Stop-The-World». Pero seamos realistas: sin la gestión automática de memoria en Java, tendríamos que escribir manualmente free() y sufrir segfaults. El recolector de basura Java no es un demonio malvado, sino un mecanismo complejo e inteligente.

Principios básicos de funcionamiento del garbage collection Java:

\n
• Un objeto se considera «basura» si no hay referencias activas a él desde la pila o campos estáticos.
\n
• El GC no puede eliminar un objeto al que todavía se hace referencia (incluso si usted se olvidó de ella).
\n
• Diferentes algoritmos de GC tienen diferentes objetivos: pausas mínimas, máximo rendimiento o ahorro de memoria.
\n

Aquí hay un ejemplo clásico de fuga de memoria, cuando un objeto se «olvida» de eliminar de una colección:

public class LeakExample {\n    private static List<byte[]> cache = new ArrayList<>();\n\n    public static void addToCache() {\n        byte[] data = new byte[1024 * 1024]; // 1 MB\n        cache.add(data); // La referencia permanece — el GC no lo tocará\n    }\n\n    public static void main(String[] args) {\n        for (int i = 0; i < 1000; i++) {\n            addToCache();\n        }\n        // Aquí habrá OutOfMemoryError, aunque los objetos ya no son necesarios\n    }\n}\n

Conclusión: la memoria en Java no se liberará mientras mantenga una referencia. Entender esto es el primer paso para escribir código eficiente.

Tipos de recolectores de basura en Java: desde Serial hasta ZGC

El Java moderno ofrece varias implementaciones de garbage collection Java. La elección depende de sus tareas:

1. Serial GC — para aplicaciones pequeñas

Recolector de un solo hilo que «congela» toda la aplicación. Se utiliza por