¿Por qué se pierde la memoria en un programa de computadora?

Las mismas razones por las que los juguetes se escapan de una sala de juegos familiar o porque el dinero se escapa de un fondo: alguien no está devolviendo lo que juega.

Clásicamente, esto proviene de construir una estructura significativa y compleja (una estructura que contiene estructuras, que contienen listas de estructuras, que apuntan a estructuras, que pueden contener la estructura original …) y no ser exhaustivos al desarmarla.

La solución a la mayoría de estos problemas ha sido introducir la recolección de basura. Language Runtime supervisa si una estructura está en uso o cuenta el número de partes del programa que “conocen” la estructura, y toma decisiones que ya no vale la pena mantener y, por lo tanto, se elimina, la próxima vez que la basura sale. Esto resuelve el problema básico al quitar (en su mayoría) el proceso de desasignación de las manos, pero introduce un nuevo problema al proporcionar a los programadores formas de “burlar” al recolector de basura, y los programadores hacen exactamente eso, tanto intencionalmente (y luego no logran administrarlo) ) y accidentalmente.

Hay una investigación constante sobre cómo hacer esto mejor. Hasta donde yo sé, no hay dos sistemas que tengan el mismo algoritmo de recolección de basura, porque las ideas siempre están siendo modificadas. Pero también hay lenguajes como Rust, que tiene un modelo de “propiedad” que hace que sea muy difícil dejar objetos a menos que sea absolutamente necesario, a expensas de enfurecer a los recién llegados que esperan poder pasar sus objetos; no hay recolección de basura, pero tiene muchos de los mismos resultados con menos agujeros.

Todo se reduce a que el compilador y el tiempo de ejecución tienen muchos problemas para adivinar si alguna vez volverás a usar algo. Y, como tratar con un niño pequeño, no se atreverá a tirar algo si no está del todo claro, porque lo sabrá por el resto de su vida. Por lo tanto, los programadores deben asumir la carga y la mayoría de los programadores … realmente no les importa. Estamos acostumbrados a que los programas se apaguen, eventualmente, y el sistema operativo recupere toda la memoria, por lo que cuando se supone que los programas se ejecutan para siempre (servidores), las cosas se quedan atrás.

En pocas palabras, ocurre cuando un bloque de memoria previamente asignado (creado usando “nuevo” o “malloc”) ya no es necesario, pero no se devuelve al montón (desde donde se asigna toda la memoria). Esto crea un bloque de memoria “huérfano” que no está siendo administrado por ninguna entidad, y por lo tanto ese bloque de memoria efectivamente “desaparece” del sistema en el sentido de que nadie puede reutilizarlo. Esta es una pérdida de memoria.

La razón por la que suceden es que a veces un bloque de memoria asignado no se libera (se devuelve al montón como memoria disponible) después de que ya no se necesita. Con el tiempo, el “código de error” que permitió que esto sucediera a menudo seguirá asignando bloques de memoria una y otra vez, pero no puede devolver ninguno de ellos al montón para que puedan reutilizarse. Es por eso que la memoria “pierde” en un programa de computadora.

Para completar una tarea adicional, los programas a menudo necesitan solicitar [también conocido como asignar] más memoria de la que usan para las tareas actuales. Después de completar la tarea adicional, el programa desasigna la memoria. Si el programa no puede desasignar la memoria, y luego vuelve a realizar la misma tarea, asignará nueva memoria [no utilizada] en lugar de reutilizar la memoria que debería haber sido desasignada cuando la tarea se completó la vez anterior.

Muchos lenguajes de programación modernos, incluido Java, tienen lo que se llama “recolección de basura”, por lo que el programa busca memoria que debería haberse desasignado y luego lo desasigna. Si la recolección de basura falla, se produce una pérdida de memoria. Un tipo de pérdida de memoria (una ocurrencia rara en cualquier sistema operativo decente, excluido Windows) involucra un programa que finaliza sin desasignar la memoria que estaba usando.