Gestin de Memoria

Ciclo de vida de memoria

Sin importar el lenguaje de programacin, el ciclo de memoria es casi siempre parecido al siguiente:

1. Reservar la memoria necesaria
2. Utilizarla (lectura, escritura)
3. Liberar la memoria una vez ya no es necesaria.

El primer y el segundo paso son explcitos en todos los lenguajes. El ltimo paso es explcito en lenguajes de bajo nivel, pero es mayormente implcito en lenguajes de alto nivel como JavaScript

Reserva de memoria en JavaScript

Inicializacin de valores

Para no agobiar al programador con reservas de memoria, JavaScript las realiza al mismo tiempo que la declaracin de los valores.

var n = 123; // reserva memoria para un nmero
var s = "azerty"; // reserva memoria para un string

var o = {
  a: 1,
  b: null,
}; // reserva memoria para un objeto y los valores que
// contiene

// (similar a objeto) reserva memoria para el arreglo y
// los valores que contiene
var a = [1, null, "abra"];

function f(a) {
  return a + 2;
} // reserva memoria para una funcion (la cual es un objeto)

// las expresiones de funcin tambien reservan memoria para un objeto
someElement.addEventListener(
  "click",
  function () {
    someElement.style.backgroundColor = "blue";
  },
  false,
);

Reserva de memoria al llamar una funcin

En ocasiones al llamar a una funcin se reserva memoria para un objeto.

var d = new Date();
// reserva memoria para un elemento del DOM
var e = document.createElement("div");

Algunos mtodos reservan memoria para nuevos valores u objetos:

var s = "azerty";
var s2 = s.substr(0, 3); // s2 es un nuevo string
// Como los strings son valores inmutables,
// JavaScript puede NO reservar memoria para este,
// y solo almacenar el rango [0, 3].

var a = ["ouais ouais", "nan nan"];
var a2 = ["generation", "nan nan"];
var a3 = a.concat(a2);
// nuevo arreglo con 4 elementos resultado de
// concatenar los elementos de a y a2

Usando valores

Usar un valor es simplemente leerlo o escribirlo en memoria reservada. Esto puede ocurrir al leer o escribir el valor de una variable o de una propiedad de un objeto, inclusive pasando un argumento a una funcin.

Liberar la memoria cuando ya no es necesaria

En este punto ocurren la mayoria de los inconvenientes con la gestin de memoria. Lo ms dficil es encontrar el cundo la "memoria ya no es necesaria". En algunas ocasiones, es necesario que el desarrollador determine en qu parte de un programa esa parte de memoria ya no es necesaria y la libere.

Los lenguajes de alto nivel incluyen una herramienta de software conocida como "recolector de basura" (garbage collector), cuya funcin es rastrear las reservas de memoria y su utilizacin, para as encontrar cundo cierta parte de la memoria ya no es necesaria, y en su momento liberarla automticamente. Este proceso es slo una aproximacin al problema general de saber cundo una parte de la memoria ya no es necesaria, ya que ste es indecidible (no puede ser resuelto por un algoritmo).

Recoleccin de basura (Garbage collection)

Como antes se mencionaba el problema general de encontrar automticamente cuando la memoria "ya no es necesaria" es indecidible. Como consecuencia, las recolecciones de basura implementan slo una restriccin a la solucin del problema general. En esta seccin se explicarn las nociones necesarias para entender los principales algoritmos de recoleccin de basura y sus limitaciones.

Referencias

La nocin principal de los algoritmos de recoleccin se basan en la nocin de referencia. Dentro del contexto de gestin de memoria, se dice que un objeto hace referencia a otro si el primero tiene acceso al segundo (ya sea de forma implcita o explcita). Por ejemplo, un objeto de JavaScript guarda una referencia a su prototipo (referencia implcita) y a cualquiera de los valores de sus propiedades (referencia explcita)

Hay que mencionar que en este contexto la nocin de "objeto" se refiere a algo ms amplio que los objetos normales de JavaScript y que tambin incluye al mbito de la funcin (o mbito de lxico global).

Recoleccin de basura a travs de conteo de referencias

ste es el algoritmo de recoleccin ms simple. Este algoritmo reduce la definicin de "un objejo ya no es necesario" a "un objeto ya no tiene ningn otro objeto que lo reference". Un objeto es considerado recolectable si existen cero referencias hacia l.

Ejemplo

var o = {
  a: {
    b: 2,
  },
};
// Se crean dos objetos. Uno es referenciado por el otro como
// una de sus propiedades.
// El otro es referenciado al ser asignado a la variable "o"
// Ninguno puede ser recolectado.

var o2 = o; // la variable "o2" es lo segundo en tener una
// referencia al objeto.
o = 1; // ahora el objeto solo tiene una referencia mediante
// la variable "o2"

var oa = o2.a; // referencia a la propiedad "a" del objeto.
// ahora el objeto posee dos referencias, una como propiedad
// la otra como la variable "oa"

o2 = "yo"; // el objeto original "o" ahora ya no tiene
// referencias a l. Podra ser recolectado.
// Sin embargo lo que haba en la propiedad "a" an
// esta refernciado en la variable "oa";
// no puede ser recolectado an

oa = null; // lo que estaba en la propiedad "a" del objeto original "o"
// ahora ya no tiene ninguna referencia.Puede ser recolectado.

Limitacin : ciclos

Existe una limitacin cuando se trata de ciclos. En el siguiente ejemplo dos objetos son creados y se referencan entre ellos -por lo que se crea un ciclo. Ellos no saldrn del mbito de la funcin despus del llamado de la funcin, con lo que seran efectivamente "ya no son necesarios" y por lo cual ser liberados. Sin embargo, el algoritmo de conteo de referencias considera que ya que cada uno de los dos objetos est referenciado por lo menos una vez, ninguno podra ser recolectado. Este simple algoritmo tiene la limitacin de que si un grupo de objetos se referencian a s mismos (y forman un ciclo), nunca pasarn a "ya no ser necesitados" y no podrn ser recolectados nunca.

function f() {
  var o = {};
  var o2 = {};
  o.a = o2; // o referenca o2
  o2.a = o; // o2 referenca o

  return "azerty";
}

f();
// Dos objetos son creados y se referencan uno al otro creando un ciclo
// Estan atrapados en el scope de la funcion despus de la llamada
// por lo que son intiles fuera de la funcin y podran ser recolectados.
// Sin embargo, el algoritmo de conteo de referencias considera que como
// ambos objetos estan referenciados (aunque sean a si mismos) ambos
// siguen en uso y por lo tanto no pueden ser recolectados.

Ejemplo real aplicado

Internet Explorer 6 y 7 son conocidos por tener recolectores de basura por conteo de referencias para los objetos del DOM. Los Ciclos son un error comn que pueden generar fugas de memoria (memory leaks) (art. en ingls):

var div;
window.onload = function () {
  div = document.getElementById("miDiv");
  div.referenciaCircular = div;
  div.muchosDatos = new Array(10000).join("*");
};

En el ejemplo anterior, el elemento del DOM "miDiv" pose una referencia circular a s mismo en la propiedad "referenciaCircular". Si la propiedad no es explcitamente removida o asignada con el valor null, un algoritmo de conteo de referencias siempre va a dejar por lo menos una referencia intacta y va a mantener el elemento del DOM activo en memoria incluso cuando es removido del DOM. Si el objeto del DOM contiene una gran cantidad de datos (ejemplificado en la propiedad "muchosDatos"), la memoria consumida por estos datos nunca ser liberada.

Algoritmo Mark-and-sweep (Marcado y barrido)

Este algoritmo reduce la definicin de "un objeto ya no es necesitado" a "un objeto es inalcanzable"

Este algoritmo asume la nocin de un grupo de objetos llamados objetos raz (en JavaScript la raz es el objeto global). Peridicamente el recolector empieza por estas races, encuentra todos los objetos que estn referenciados por estas races, y luego todos los objetos referenciados de estos, etc. Empezando por las races, el recolector de esta forma encontrar todos los objetos que son alcanzables y recolectar los objetos inalcanzables.

Este algoritmo es mejor que el anterior ya que "un objeto tiene cero referencias" equivale al "objeto es inalcanzable". Esto no suceda asi en el algoritmo anterior cuando se trataba de un ciclo.

Desde el 2012, todos los navegadores incluyen un recolector de basura basado en mark-and-sweep. Todas las mejoras realizadas en el campo de Recoleccin de basura en JavaScript (recoleccin generacional/incremental/concurrida/paralela) en los ultimos aos son mejoras a la implementacin del algoritmo, pero no mejoras sobre el algoritmo de recoleccin ni a la reduccin de la definicion de cuando"un objeto ya no es necesario".

Los ciclos son problema del pasado

En el primer ejemplo, despus de que la llamada a una funcin termina, los dos objetos ya no son referenciados por nada alcanzable desde el objeto global. De esta forma sern identificados como inalcanzables por el recolector de basura.

Lo mismo ocurre en el segundo ejemplo. Una vez que el elemento div y sus mtodos se hacen inalcanzable desde los objetos raz, ambos pueden ser recolectados a pesar de que estn referenciados los unos de los otros.

Limitacin: los objetos necesarios se hacen inalcanzables de forma explcita

Aunque esto est marcado como una limitacin, se puede encontrar muy poco en la prctica. sta es la razn por la cul la recoleccin de basura es poco tomada en cuenta.

Vase tambin

• IBM article on "Memory leak patterns in JavaScript" (2007) (art. en ingls)
• Kangax article on how to register event handler and avoid memory leaks (2010) (art. en ingls)
• Performance (art. en ingls)