Cómo evitar fugas de memoria

Se produce una fuga de memoria cuando los objetos se acumulan en la memoria porque una referencia impide que el GC los recopile, aunque el programa ya no los necesite.

Almacenar objetos en una tabla global sin eliminarlos es una fuga clásica. La tabla global siempre es una raíz del GC.

Limite el tamaño de la caché y expulse las entradas antiguas mediante una estrategia LRU o un límite de tamaño sencillo.

Registrar un closure como listener de eventos y no cancelar nunca su registro mantiene activos tanto el closure como sus upvalues.

Almacene los listeners en una tabla de valores débiles para que, si se recopila el objeto suscriptor, su listener se elimine automáticamente.

Un closure que captura una tabla grande la mantiene activa mientras exista el closure, aunque solo se necesite una pequeña parte de la tabla.

Extraiga únicamente los valores necesarios antes de crear el closure, de modo que la tabla grande pueda recopilarse.

Una coroutine suspendida sigue activa y conserva todas sus variables locales. Las coroutines terminadas (con estado "dead") pueden recopilarse. No pierda nunca el control de las coroutines suspendidas.

Concatenar strings en un bucle con .. crea muchas strings intermedias. Use table.concat para construir strings grandes de forma eficiente.

Use collectgarbage("count") antes y después de las operaciones para medir el crecimiento de la memoria. Registre los crecimientos sospechosos para acotar el origen de la fuga.

Herramientas como luamemprof y contadores de asignaciones personalizados mediante debug.sethook pueden rastrear qué rutas de código asignan más memoria.

¿Qué patrón tiene más probabilidades de provocar una fuga de memoria?

Las fugas en Lua se deben a cachés sin límites, listeners cuyo registro no se cancela, closures que capturan tablas grandes y coroutines suspendidas olvidadas. Use tablas débiles, cachés limitadas y collectgarbage("count") para detectar y prevenir fugas.