Vazamento de memória: diferenças entre revisões

← Ver a alteração anterior Ver a alteração posterior →

Conteúdo apagado Conteúdo adicionado

Em linha

Revisão das 15h22min de 25 de maio de 2007

Memory leak, ou vazamento de memória, é um fenômeno que ocorre em sistemas computacionais quando uma porção de memória, alocada para uma determinada operação, não é liberada quando não é mais necessária. A ocorrência de vazamentos de memória é quase sempre relacionada a erros de programação e pode levar a falhas no sistema se a memória for completamente consumida.

Exemplo

O exemplo abaixo, escrito na linguagem de programação C, mostra um programa de computador que possui um vazamento de memória. Após algum tempo de execução este programa irá consumir toda a memória disponível e irá falhar.

#include <stdio.h>
#include <stdlib.h>

void f(void)
{
    void* s;
    s = malloc(50); /* obtém a memória */
    return;  /* memory leak - ver nota abaixo */ 
    /* 
     * A memória é obtida e disponibilizada em s.
     * Após o retorno da função, o ponteiro é destruído e
     * perde-se a referência a esta porção de memória.
     * 
     * Este código pode ser consertado se a função f() incluir
     * a operação "free(s)" antes do retorno ou se o código
     * que chama f() fizer a chamada para a operação free().
     */
}

int main(void)
{
    /* Este loop infinito chama a função f(), definida acima */
    while (1) f(); /* Cedo ou tarde a chamada à função irá falhar, devido à um
                      um erro de alocação na função malloc, quando a memória terminar.*/
    return 0;
}

@@ Linha 1: / Linha 1: @@
+'''Memory leak''', ou '''vazamento de memória''', é um fenômeno que ocorre em [[sistema computacional|sistemas computacionais]] quando uma porção de memória, alocada para uma determinada operação, não é liberada quando não é mais necessária. A ocorrência de vazamentos de memória é quase sempre relacionada a erros de programação e pode levar a falhas no sistema se a memória for completamente consumida.
-{{revisão}}
-'''Memory leak''', ou '''vazamento de memória''', é um fenômeno que ocorre em [[sistema computacional|sistemas computacionais]] quando uma porção de memória precisa ser alocada para uma determinada operacão, mas não é liberada depois. A existência de ''memory leak'' é considerada um grave erro de programacão que pode transformar um ''software'' em um grande consumidor de [[memória RAM]].
+==Exemplo==
-Considere o codigo abaixo:
+O exemplo abaixo, escrito na [[C (linguagem de programação)|linguagem de programação C]], mostra um [[programa de computador]] que possui um vazamento de memória. Após algum tempo de execução este programa irá consumir toda a memória disponível e irá falhar.
+ #include <stdio.h>
-<pre>
+ #include <stdlib.h>
-main()
-{
+ void f(void)
-	char *p1;
+ {
-	char *p2;
+     void* s;
+     s = malloc(50); /* obtém a memória */
+     return;  /* memory leak - ver nota abaixo */
+     /*
+      * A [[Memória (computador)|memória]] é obtida e disponibilizada em s.
+      * Após o retorno da [[Função (computação)|função]], o [[Ponteiro (programação)|ponteiro]] é destruído e
+      * perde-se a referência a esta porção de memória.
+      *
+      * Este código pode ser consertado se a função f() incluir
+      * a operação "free(s)" antes do retorno ou se o código
+      * que chama f() fizer a chamada para a operação free().
+      */
+ }
+ int main(void)
+ {
+     /* Este ''loop'' infinito chama a função f(), definida acima */
+     while (1) f(); /* Cedo ou tarde a chamada à função irá falhar, devido à um
+                       um erro de alocação na função malloc, quando a memória terminar.*/
+     return 0;
+ }
+[[Categoria:Depuração]]
-	p1 = (char *)malloc(1024);
-	p2 = (char *)malloc(1024);
-	if(p1 == NULL || p2 == NULL) return -1;
-	free(p1);
-	free(p2);
-}
-</pre>
-No exemplo são declarados 2 ponteiros para um tipo char, logo em seguida é alocado 1024 bytes para cada ponteiro e é feito um teste para ver se em algum momento a alocacão dinamica de memória falhou. Caso a alocacão tenha falhado para algum dos ponteiros o programa é abortado. Poderia ter acorrido uma falha de alocacão se não houvesse memória suficiente disponivel. Logo abaixo do 'if' a memoria alocada é liberada.
-Agora vamos ao problema!
-Imagine que a memoria para *p1 tenha sido alocada com sucesso, mas por algum motivo desconhecido, o mesmo não ocorreu para *p2. Quando algum erro de alocacão ocorre, o valor retornado ao ponteiro é NULL.
-O operador 'if' ira verificar se o valor de *p1 é igual a NULL e fará o mesmo para *p2, como o valor de *p2 de fato é NULL o programa ira ser abortado, observe que as instrucoes 'free', utilizadas para liberar a memória previamente alocada, nunca serão executadas e memoria alocada para *p1 nunca será liberada.
-Vejamos agora uma versão que trata essa falha:
-<pre>
-main()
-{
-	char *p1;
-	char *p2;
-	p1 = (char *)malloc(1024);
-	p2 = (char *)malloc(1024);
-	if(p1 == NULL || p2 == NULL){
-		free(p1);
-		free(p2);
-		return -1;
-	}
-	free(p1);
-	free(p2);
-}
-</pre>
-No programa acima, caso alguma instrucão 'malloc' tenha falhado, a instrucão 'free' á executada e somente depois disso o 'return'. Caso o valor dos ponteiros seja NULL, a instrucão 'free' não fará nada.
-Abaixo do 'if' as instrucões 'free' são repetidas para que a memória alocada seja liberada caso nao acorra erros.
-É claro que esse exemplo é muito simples, uma falha assim seria rapidamente encontrada e corrigida. Mas esse tipo de falha ocorre em varios programas conhecidos, como o Apache entre outros.
-Imagine esse tipo de acontecimento dentro de um loop, muita memória seria desperdicada, e em pouco tempo consumiria toda a memória disponivel do sistema.
-[[Categoria:Programação]]
 [[ar:تسرب الذاكره]]