Saltearse al contenido

Fugas de memoria reales

Un programa en C pierde memoria cuando olvida un free. En Python no se puede olvidar: el contador la libera sola. Lo que sí se puede es seguir apuntando a objetos que ya no sirven, y entonces el contador nunca llega a cero. Eso no es una fuga del lenguaje; es una decisión de diseño que nadie revisó.

No hay memoria perdida: hay referencias vivas que ya no necesitas.

1. Caché sin límite.

cache = {}
def caro(x):
if x not in cache:
cache[x] = calcular(x)
return cache[x]

Crece con cada entrada distinta y mantiene vivos los resultados. En un proceso de semanas, es la fuga más común. Arreglo: lru_cache(maxsize=...) o WeakValueDictionary.

2. Registro global de objetos.

SUSCRIPTORES = []
def suscribir(fn):
SUSCRIPTORES.append(fn) # nunca se quita

Cada suscribir añade una referencia permanente, y la lista no distingue entre suscriptores vivos y muertos. Arreglo: WeakSet, o un desuscribir explícito.

3. Clausuras que capturan de más.

def crear_manejador(config):
def manejar(evento):
return config["tema"] # retiene todo el dict
return manejar

El manejador se queda con la configuración entera porque la usa en una línea. Arreglo: extraer el valor antes de crear la clausura (Parte III, capítulo 02).

4. Excepciones que guardan el traceback.

try:
...
except Exception as e:
ERRORES.append(e) # e guarda el traceback → guarda los marcos → guarda todo

Una excepción almacenada mantiene vivos los objetos locales de la función donde se lanzó, porque el traceback referencia los marcos. Arreglo: guardar str(e) o e.args, no la excepción.

tracemalloc compara dos momentos y te dice qué líneas crecieron:

import tracemalloc
tracemalloc.start()
hacer_trabajo() # fase 1
snap1 = tracemalloc.take_snapshot()
hacer_trabajo() # fase 2: debería ser idéntica
snap2 = tracemalloc.take_snapshot()
for stat in snap2.compare_to(snap1, "lineno")[:5]:
print(stat)

Se ejecutan las dos fases en el mismo proceso (o se compara el snapshot de arranque con el de después de N peticiones) y se mira qué línea creció. Si la fase 2 añade memoria que la fase 1 no, esa línea es la fuga. Es la técnica más directa que existe en la biblioteca estándar.

El coste de medir la memoria
Modo Crear 50 000 objetos
Sin tracemalloc 7.53 ms
Con tracemalloc 49.99 ms

python mediciones/05-01-04-memoria.py

Seis veces más lento. Por eso se mide en un proceso aparte o con la instrumentación activada sólo durante la fase sospechosa: nunca en producción continua.

Contar objetos por tipo, que es más rápido

Sección titulada «Contar objetos por tipo, que es más rápido»

Antes de tracemalloc hay un diagnóstico de treinta segundos: contar cuántos objetos de cada tipo hay vivos.

import gc
from collections import Counter
conteo = Counter(type(o).__name__ for o in gc.get_objects())
conteo.most_common(5)

Si Sesion aparece 40 000 veces cuando debería haber 200, ya sabes dónde mirar sin abrir un snapshot. gc.get_objects() devuelve sólo los objetos que el recolector rastrea (listas, dicts, instancias), no los enteros ni las cadenas, y eso es exactamente lo que interesa.

La limitación: dice qué se acumula, no quién lo retiene. Para eso, el snapshot comparado.

  • Si el proceso es corto. Un script que dura segundos no necesita gestión fina.
  • Si el crecimiento está acotado. Una caché que crece hasta 10 000 entradas y se estabiliza no es una fuga: es un límite que hay que documentar.
  • Sin una medición que lo demuestre. «Consume mucha memoria» no es un diagnóstico; un snapshot comparado sí.

Un servicio web aumenta 40 MB al día y se reinicia cada semana. Describe el procedimiento para localizar la causa en una hora, sin acceso a un profiler comercial.

Solución
  1. Confirmar que es una fuga y no caché legítima. Comparar tracemalloc al arrancar y tras N peticiones. Si crece linealmente con las peticiones y no se estabiliza, es fuga.
  2. Aislar el tipo de objeto. gc.get_objects() filtrado por tipo, o tracemalloc agrupado por lineno, señala la línea que asigna.
  3. Reproducir en local con el mismo tráfico simulado y dos snapshots espaciados.
  4. Sospechosos habituales, en orden: caché de respuestas sin límite, handlers de logging añadidos por petición, excepciones guardadas con traceback, sesiones o clientes HTTP creados por petición y no cerrados.

El presupuesto de una hora se reparte: 15 minutos confirmar, 20 reproducir, 20 leer el snapshot, 5 arreglar y verificar con otro snapshot.

La instrumentación (paso 1 y 2) es la única que requiere código; el resto es leer. Y el arreglo casi siempre es un límite (maxsize) o un WeakValueDictionary, no un del.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 6.
  • CPython 3.13: Modules/tracemalloc.c, Modules/gcmodule.c.
  • Mediciones: mediciones/05-01-04-memoria.py.
  • 01 · El ciclo de vida: la regla que estas fugas rompen.
  • 03 · weakref: la referencia que no impide liberar.
  • 04 · Medir: cómo se confirma un diagnóstico.