Fugas de memoria e hinchazón — qué es, causas y cómo evitarlo

¿Qué es una fuga de memoria y la hinchazón de la aplicación?

Fuga de memoria — una situación en la que un objeto que ya no necesita la aplicación sigue siendo retenido en el heap porque una referencia activa desde el conjunto raíz (GC Root) aún apunta a él. El recolector de basura considera que dicho objeto está vivo y no lo elimina.

Hinchazón de memoria — un problema más amplio en el que la aplicación consume más memoria de la necesaria para realizar sus tareas actuales. Causas: almacenamiento en caché excesivo, duplicación de objetos, estructuras de datos subóptimas y fragmentación del heap.

En Android, cada aplicación tiene un heap limitado (generalmente 64–512 MB según el dispositivo y la versión del SO). En iOS, el límite es menos estricto, pero el sistema envía una advertencia de memoria al acercarse al umbral.

Según el Facebook Engineering Blog, las fugas de memoria causan ~15% de los informes de crash en aplicaciones móviles. En Android, esto se ve agravado por los ANR debidos a las frecuentes pausas del GC cuando la memoria es escasa.

Patrones comunes de fugas de memoria en Android e iOS

Referencia estática a Activity — una fuga clásica de Android. Si un campo estático o singleton mantiene una referencia a una Activity, esta no será recolectada por el GC incluso después de finish() mientras el singleton esté vivo. Una Activity es un objeto pesado que contiene una jerarquía de vistas, recursos y Context.

object LeakHolder {
    var activityRef: Activity ?= null // leak: static reference to Activity
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle ?= null) {
        super.onCreate(savedInstanceState)
        LeakHolder.activityRef = this // ❌ MainActivity will never be GC'd
    }
}

Clases anónimas y lambdas — retienen implícitamente una referencia a la clase externa. Si un Runnable o Callback se pasa a un servicio externo y la Activity se destruye, el objeto de la clase anónima aún permanece en la cola e impide que la Activity sea recolectada.

• Handler con retardo — si la Activity se destruye pero Handler.postDelayed aún no se ha ejecutado, la Activity se fuga
• Thread y AsyncTask — al rotar la pantalla, la Activity se recrea mientras el Thread antiguo sigue manteniendo una referencia a la Activity anterior
• Retrofit/Callback — un Callback anónimo mantiene una referencia al presenter o fragment
• Observadores — suscripciones de LiveData o RxJava sin cancelación en onDestroy

En iOS, el principal problema son los retain cycles: dos objetos mantienen referencias fuertes entre sí y ARC no puede poner a cero el contador de referencias de ninguno. Un caso típico: un closure que captura self fuertemente y self que mantiene una referencia al closure.

¿Cómo detectar fugas de memoria?

LeakCanary — una biblioteca de Square para la detección automática de fugas en Android. Tras destruir una Activity o Fragment, comprueba si el objeto fue recolectado por el GC. Si no, hace un heap dump y muestra el trace de la fuga.

// LeakCanary 2.x — auto-integration via Application
class ExampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        // LeakCanary auto-installs in debug build
        // via ContentProvider — zero code setup
    }
}

// Force check invocation
AppWatcher.objectWatcher.watch(watchedObject, "leak description")

Android Studio Profiler — una herramienta integrada para la monitorización de memoria en tiempo real. Permite grabar un heap dump, encontrar objetos sospechosos (Retained Size > 1 MB) y rastrear la ruta GC root hasta cada objeto.

Para iOS, usa el Xcode Memory Graph Debugger. Visualiza el grafo de objetos en memoria, muestra retain cycles y permite detectar instantáneamente referencias circulares. Instruments > Allocations también está disponible para monitorización a largo plazo.

Estrategias de prevención

WeakReference — un mecanismo básico para referencias que no deben interferir con la recolección de basura. Si el GC decide recolectar un objeto, WeakReference devuelve null. Se usa para callbacks, listeners y referencias a componentes de UI desde hilos en segundo plano.

Componentes Lifecycle-aware — un enfoque arquitectónico implementado en Android Jetpack (Lifecycle, LiveData, Flow, coroutines). Las suscripciones se cancelan automáticamente en onDestroy, eliminando la principal clase de fugas.

class MyViewModel : ViewModel() {
    private val _data = MutableLiveData<List<User>>()
    val data: LiveData<List<User>> get() = _data

    fun loadData() {
        viewModelScope.launch {
            val result = repository.fetchData()
            _data.postValue(result)
            // coroutine auto-cancels on onCleared()
        }
    }
}

viewModelScope y lifecycleScope — CoroutineScope integrados en Android que se cancelan en el evento de ciclo de vida correspondiente. Esto elimina las fugas a través de corutinas — el escenario más común en el desarrollo moderno de Android.

• No uses referencias estáticas a Context, Activity, View o Fragment
• Cancelas todas las suscripciones de RxJava en disposeBag / CompositeDisposable en onDestroy
• Usa [weak self] / [unowned self] en closures de iOS para prevenir retain cycles
• Verifica Bitmap y objetos grandes — deben ser reciclados o anulados

Herramientas de perfilado de memoria

Memory Profiler in Android Studio — la herramienta principal para la monitorización del heap. Muestra asignaciones en vivo, instantáneas del heap y recuentos de objetos por tipo. Permite grabar un volcado y analizarlo en MAT (Memory Analyzer Tool) para encontrar objetos sospechosos.

Eclipse MAT — un analizador de heap dump de escritorio. Tras cargar un archivo HPROF de Android Studio, MAT construye un árbol dominador, muestra el retain size de cada objeto y ofrece un análisis automático de fugas sospechosas mediante el Leak Suspects Report.

Xcode Memory Graph — un depurador visual de retain cycles. Al hacer clic en el botón Memory Graph Debugger, Xcode detiene la aplicación, construye un grafo completo de objetos en memoria y resalta los retain cycles en rojo.

Según Google I/O 2023, las aplicaciones que usan LeakCanary en builds de depuración reducen los crashes relacionados con la memoria en un 30–50% en los primeros 2 meses tras su adopción. Se recomienda añadir LeakCanary durante la fase de inicio del proyecto.