memory leaks - leaks - La mejor definición de fuga de memoria

memory leak juego (11)

El proceso en el que los recursos de memoria se asignan y no se lanzan correctamente una vez que ya no son necesarios, a menudo introducidos a través de malas prácticas de codificación.

En algunos idiomas, existen formas de ayudar a prevenirlos, aunque la mejor manera de evitarlos es mediante la observación diligente de las rutas de ejecución de código y las revisiones de código. Mantener los métodos cortos y singularmente propuestos ayuda a mantener el uso de los recursos estrechamente delimitado y menos propenso a perderse en la confusión.

Siento que los desarrolladores hablan de fugas de memoria, pero cuando les preguntas qué significa eso, muchos no tienen idea. Para evitar estas situaciones, decidamos una.

Por favor, no hay definiciones de Wikipedia ...

¿Cuál es su mejor definición de fuga de memoria y cuál es la mejor manera de prevenirla?

Estas son algunas técnicas para prevenir / detectar fugas de memoria:

Considere su algoritmo en términos de consumo de memoria. Otros encuestados han mencionado el hecho de que no tiene que perder el puntero a un elemento asignado para perder memoria. Incluso si su implementación contiene errores de puntero cero, de todos modos puede perder memoria de manera efectiva si mantiene los elementos asignados mucho después de que realmente los necesite.
Perfile su aplicación. Puede usar herramientas de depuración de memoria como Valgrind o Purify para buscar fugas.
Prueba de caja negra. Observe qué le sucede a su código compilado después de alimentarlo con grandes conjuntos de datos, o permita que se ejecute durante largos períodos de tiempo. Vea si su huella de memoria tiene una tendencia a crecer sin límite.

Hay dos formas en que se puede definir una pérdida de memoria.

En primer lugar, si los datos no se liberan cuando ya no hay referencias al mismo, esos datos son inalcanzables (a menos que tenga algún puntero corrupto o lea más allá de los datos en un búfer o algo así). Básicamente, si no libera / elimina los datos asignados en el montón, se vuelve inutilizable y simplemente desperdicia memoria.

Puede haber casos en los que se pierda un puntero pero aún se puede acceder a los datos. Por ejemplo, si almacena el puntero en un int, o almacena un desplazamiento en el puntero (usando la aritmética del puntero), aún puede recuperar el puntero original.

En esta primera definición, los recolectores de basura manejan los datos, que llevan un registro del número de referencias a los datos.

En segundo lugar, la memoria se pierde esencialmente si no se libera / elimina cuando se usó por última vez. Se puede referenciar, e inmediatamente libre, pero se ha cometido el error de no hacerlo. Puede haber una razón válida (por ejemplo, en el caso en que un destructor tiene algún extraño efecto secundario), pero eso indica un mal diseño del programa (en mi opinión).

Este segundo tipo de pérdida de memoria a menudo ocurre cuando se escriben pequeños programas que usan archivos IO. Abre el archivo, escribe sus datos, pero no lo cierra una vez que haya terminado. El ARCHIVO * aún puede estar dentro del alcance y fácilmente cerrable. Nuevamente, puede haber alguna razón para hacer esto (como bloquear el acceso de escritura por otros programas), pero para mí eso es una bandera de mal diseño.

En esta segunda definición, los recolectores de basura no manejan los datos, a menos que el compilador / intérprete sea lo suficientemente inteligente (o tonto) como para saber que ya no se usará más, y esta liberación de los datos no causará ningún efecto secundario.

Memoria asignada que no se puede usar porque se ha perdido la referencia a la misma.

Memoria que no se desasigna cuando ya no es necesaria, y ya no es "alcanzable". Por ejemplo, en código no administrado, si uso "nuevo" para crear una instancia de un objeto, pero no uso "eliminar" cuando termine con él (y mi puntero se ha salido del alcance o algo así).

La mejor manera de prevenirlos probablemente dependa de a quién le pregunte y qué idioma está usando. La recolección de basura es una buena solución, por supuesto, pero puede haber algunos gastos generales asociados a esto, que no es un gran problema a menos que el rendimiento sea su principal preocupación. La recolección de basura no siempre está disponible, de nuevo, dependiendo del idioma que esté usando.

De forma alternativa, puede asegurarse de que tenga las eliminaciones y / o destructores apropiados en su lugar. También hay muchos métodos y herramientas para detectar fugas de memoria, pero esto dependerá del idioma y / o IDE que esté utilizando.

editar: esta respuesta es incorrecta. Lo dejo como un ejemplo de lo fácil que es confundirse con algo que crees que sabes muy bien. Gracias a todos los que señalaron mi error.

Una fuga de memoria es: Un error de programación. Su software toma prestada parte de la memoria del sistema, la usa y luego no la devuelve al sistema cuando finaliza. Esto significa que ese pedazo particular de memoria nunca puede ser utilizado por ningún otro programa hasta que el sistema se reinicie. Muchas de estas fugas podrían agotar toda la memoria disponible, lo que daría como resultado un sistema completamente inútil.

Para evitar fugas de memoria, practique RIIA y siempre pruebe su software. Hay muchas herramientas disponibles para esta tarea.

Pérdida de memoria : no se puede liberar memoria que ya no necesita antes:

El programa termina
Se asigna memoria adicional

La mejor manera de evitar fugas de memoria: liberar memoria tan pronto como ya no sea necesaria.

Definición : falla al liberar memoria después de la asignación

Mozilla tiene una excelente página de herramientas para rastrear fugas de memoria.

Todas las definiciones dadas aquí (en el momento en que escribí esto, hemos obtenido mejores respuestas desde entonces) no solucionan un caso límite:

Usted tiene un singleton que asigna memoria al momento de la creación y esta memoria normalmente se mantiene mientras el programa se está ejecutando aunque el uso actual esté hecho y no se sabe si se realizará o no un uso futuro. Esto generalmente se hace debido a la sobrecarga de recrearlo.

Con el estándar "no se puede liberar cuando se termine con esto", esto se consideraría una fuga y he visto que las herramientas de informe de fugas llaman tales cosas a pérdidas ya que la memoria todavía estaba en uso. (Y, de hecho, el código puede no contener código capaz de limpiar el objeto).

Sin embargo, me he encontrado con un código de esta naturaleza en las bibliotecas de compiladores antes incluso cuando el costo de volver a crear el objeto no es tan bueno.

¿Fuga o no?

Hay dos definiciones (al menos para mí):

Definición ingenua: no se libera la memoria inalcanzable , que ya no puede ser asignada de nuevo por ningún proceso durante la ejecución del proceso de asignación. Esto se puede curar principalmente mediante el uso de técnicas GC (recolección de basura) o detectar mediante herramientas automatizadas.

Definición sutil: Error al liberar memoria alcanzable que ya no es necesaria para que su programa funcione correctamente. Esto es casi imposible de detectar con herramientas automáticas o por programadores que no están familiarizados con el código. Si bien técnicamente no es una filtración, tiene las mismas implicaciones que la ingenua. Esta no es solo mi propia idea. Puede encontrar proyectos que están escritos en un lenguaje recogido de basura, pero aún mencionar la posibilidad de corregir fugas de memoria en sus registros de cambios.

En ciencias de la computación, una fuga de memoria es un tipo particular de consumo involuntario de memoria por un programa de computadora donde el programa no puede liberar memoria cuando ya no es necesaria. Esta condición es normalmente el resultado de un error en un programa que le impide liberar memoria que ya no necesita.