Gestão de memória

Linguagens de baixo nível, como o C, têm funções pimitivas de gestão de memória, como por exemplo, malloc() e free(). Por outro lado, os valores em JavaScript são alocados quando coisas (objetos, variáveis de texto, etc.) são criadas e "automaticamente" libertadas da memória quando deixam de ser utilizadas. O último processo é chamado de coleção do lixo. Este "automatismo" é uma fonte de mal entendidos e transmite aos programadores de JavaScript ( e aos de outras linguagens de alto nível ) a impressão de que podem decidir não se preocupar com a gestão da memória. Isto é uma erro.

Independentemente da linguagem de programação, o ciclo da duração da memória é praticamente sempre o mesmo:

1. Alocação da memória necessária
2. Utilização da memória alocada ( leitura, escrita )
3. Libertar a memória alocada quando já não é necessária

A segunda etapa é explícita em todas as linguagens. A primeira e a última etapa são explícitas em linguagens de baixo nível mas são, na sua maioria, implícitas em linguagens de alto nível como o JavaScript.

Inicialização do valor

Com o intuito de não incomodar o programador com alocações, o JavaScript fá-lo juntamente com a declaração de valores.

var n = 123; // alocação da memória para um número
var s = 'azerty'; // alocação de memória para um texto

var o = {
  a: 1,
  b: null
}; // alocação de memória para um objeto e o seu conteúdo

// (similar ao objeto) alocação de memória para a matriz e
// os seus valores
var a = [1, null, 'abra'];

function f(a) {
  return a + 2;
} // alocação de uma função (que é um objeto que pode ser chamado)

// Expressões de funções também alocam um objeto
someElement.addEventListener('click', function() {
  someElement.style.backgroundColor = 'blue';
}, false);

Alocação através de chamadas de funções

Algumas chamadas de funções resultam na alocação de um objeto.

var d = new Date(); // alocação de um objeto Date

var e = document.createElement('div'); // alocação de um elemento DOM

Alguns métodos alocam novos valores ou objetos:

var s = 'azerty';
var s2 = s.substr(0, 3); // s2 é uma nova variável de texto
// Dado que as variáveis de texto são de valor imutável,
// o JavaScript pode decidir não alocar memória,
// mas apenas armazenar o intervalo [0, 3].

var a = ['ouais ouais', 'nan nan'];
var a2 = ['generation', 'nan nan'];
var a3 = a.concat(a2);
// nova matriz de 4 elementos resultando
// da concatenação dos elementos de a e a2

Basicamente, a utilização de valores significa a leitura e a escrita na memória alocada. Isto pode ser feito através da leitura ou escrita do valor de uma variável ou uma propriedade de um objeto ou até a passagem de um argumento para uma função.

A maioria dos problemas de gestão de memória aparecem nesta fase. A tarefa mais difícil é descobrir quando "a memória alocada já não é necessária". Em geral, requer que o programador determine quando, no seu código, este pedaço de memória já não é necessário e a liberte.

Linguagens de alto nível têm embutidas um pedaço de código chamado "coleção de lixo", cuja tarefa é rastrear a alocação e uso da memória, para detetar quando um pedaço de memória já não é necessário e neste caso, automaticamente libertá-la. Este processo é uma aproximação dado que o problema geral de se saber quando um pedaço da memória é necessário, é indecisível ( não pode ser solucionado por um algoritmo ).

Como mencionado anteriormente, o problema geral de automaticamente descobrir quando alguma ocupação de memória "já não é necessária", é indecisível. Como consequência, as coleções de lixo implementam uma restrição à solução para o problema em geral. Esta seção explicará as noções necessárias para se compreender os principais algoritmos da coleção de lixo e as suas limitações.

A noção principal dos algoritmos de coleção de lixo baseiam-se na noção de referência. Dentro do contexto da gestão de memória, um objeto é dito referenciar outro objeto, se o primeiro tiver acesso ao segundo ( quer implicitamente quer explicitamente ). Por exemplo, um objeto JavaScript tem uma referência ao seu protótipo ( referência implícita )  e aos valores das suas propriedades ( referência explícita ).

Neste contexto, a noção de "objeto" é expandida a algo mais abrangente que um objeto JavaScript e também contém âmbitos de funções ( ou âmbito léxico global ).

Este é o algoritmo mais simples da coleção de lixo. Este algoritmo reduz a definição de "um objeto já não é necessário" para "um objeto já não é referenciado por nenhum outro objeto". Um objeto é considerado coletável para a coleção de lixo se tiver nenhuma referenciação por parte de outro objeto.

Exemplo

var o = {
  a: {
    b: 2
  }
};
// 2 objetos criados. Um é referenciado por outro como sendo suas propriedades
// O outro é referenciado por virtude ao ser assignado para a variável 'o'
// Obviamente, nenhum podem ser coletado pela coleção de lixo


var o2 = o; // A variável 'o2' é a segunda coisa que
            // tem uma referência ao objeto
o = 1;      // agora, o objeto que era originalmente o 'o' tem uma referência única
            // corporificada pela variável 'o2'

var oa = o2.a; // referência à propriedade 'a' do objeto.
               // Este objeto tem agora 2 referências: uma como propriedade,
               // a outra como variável 'oa'

o2 = 'yo'; // O objeto que era o original 'o' tem agora zero
           // referências a si próprio. Pode ser coletado para a coleção de lixo
           // No entanto, a propriedade 'a' ainda é referenciada pela
           // variável 'oa', logo não pode ser libertado

oa = null; // A propriedade 'a' do objeto original 'o'
           // tem zero referências a si próprio. Pode ser coletado para a  coleção de lixo.

Limitação: ciclos

Existe uma limitação no que se refere aos ciclos. No exemplo seguinte, dois objetos são criados e referenciam-se mutuamente, criando um ciclo. Estes sairão do âmbito depois de uma chamada a uma função e como tal, são efetivamente inúteis e podem ser libertados. No entanto, o algoritmo de contagem de referências considera que os dois objetos têm pelo menos uma referenciação; nenhum pode ser coletado para a coleção de lixo .

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

  return 'azerty';
}

f();

Exemplo de aplicação real

O Internet Explorer 6 e 7 são conhecidos por terem um coletor de contagem de referenciações de coleções de lixo para os objetos DOM. Os ciclos são um erro comum que podem gerar percas de memória:

var div;
window.onload = function() {
  div = document.getElementById('myDivElement');
  div.circularReference = div;
  div.lotsOfData = new Array(10000).join('*');
};

No exemplo acima, o elemento DOM "myDivElement" tem uma referência circular a si próprio na propriedade "circularReference". Se a propriedade não for explicitamente removida ou anulada, o coletor de contagem de referências da coleção de lixo, irá sempre ter uma referenciação intacta e irá manter o elemento DOM na memória mesmo quando for removido da árvore DOM. Se o elemento DOM contém bastante dados ( ilustrado no exemplo acima com a propriedade "lotsOfData" ), a memória consumida por estes dados nunca será libertada.

Este algoritmo reduz a definição de "um objeto já não é necessário" para "um objeto é inalcançável".

Este algoritmo assume o conhecimento de um conjunto de objetos chamados "roots" ( em JavaScript, a root - raiz - é um objeto global ). Periodicamente, a coleção de lixo começará pela raíz e procurará todos os objetos que são referenciados a partir desta; depois todos os que são referenciados a partir dos seguintes, etc.. Começando pela raiz, o coletor de lixo irá localizar objetos inalcançáveis; coletando-os.

Este algoritmo é melhor do que o anterior dado que "um objeto tem zero referenciações" leva a um objeto inalcançável. O contrário não é verdade como vimos nos ciclos.

Desde 2012, todos os modernos navegadores de Internet contêm um coletor de marcação e limpeza. Todos os melhoramentos feitos na área da coleção de lixo no JavaScript ( generalização / incrementação / concorrência / coleção de lixo paralela ) nos últimos anos são implemetações de melhoramento deste algoritmo, mas não melhoramentos do algoritmo de coleção de lixo em si nem a sua redução à definição de que quando "um objeto já não é necessário".

Os ciclos já não são um problema.

No primeiro exemplo acima, depois do retorno da chamada à função, 2 objetos já não são referenciados por algo alcançável no objeto global. Consequentemente, irão ser localizados pelo coletor da coleção de lixo.

Limitações: os objetos necessitam de ser explicitamente inalcançáveis

Apesar disto estar marcado como uma limitação, é um caso que raramente ocorre na prática pelo que é por isto que ninguém se preocupa muito com a coleção de lixo.

• Aritgo da IBM sobre "Padrões de percas de memória no JavaScript" (2007)
• Artigo da Kangax sobre como registar um apontador de evento e evitar percas de memória (2010)
• Desempenho