stack heap

Pila y Montculo de memoria (Heap and Stack Memory)

Organizacin de lenguajes y compiladores 2

Aux. Oscar Estuardo de la Mora

Pila y Montculo de memoria (Stack memory, Heap Memory)

Las computadoras en lenguaje de bajo nivel deben trabajar en modo de pila al hacer llamadas a mtodos. Por ejemplo si tenemos la siguiente estructura de cdigo:

void suma(){ //cdigo } void main(){ //cdigo suma(); } Si tenemos:

void resta(){

//cdigo

}

void suma(){

//cdigo

resta();

}

void main(){

//cdigo

suma();

//cdigo

}

El programa ejecutar primero el mtodo main, y luego

el mtodo suma, pero mientras el mtodo suma esta

ejecutndose, el mtodo main estar esperando.

El programa ejecutar primero el mtodo

main, y luego el mtodo suma, el mtodo

main esta esperando, pero en el mtodo

suma esta llamando al mtodo resta,

entonces el mtodo suma tambin

esperar la finalizacin del mtodo resta.

Luego que el mtodo resta termina,

regresa al mtodo suma y cuando el

mtodo suma termina regresar al mtodo

main.




Conforme se estn llamando los mtodos el tamao de la pila de memoria (stack memory) crece, conforme a los requerimientos que el programa tenga, si

llamamos a un mtodo recursivo por ejemplo:

void factorial(int num){

if(i == 0)

return;

else

factorial(num-1);

}

Este pedir memoria hasta que se cumpla la condicin, por ejemplo:

void main(){

factorial(3);

}

Podemos ver en la grfica que conforme se llaman mtodos, se pide memoria para poder llamar al siguiente mtodo factorial, mientras el otro se queda

esperando a que termine, podemos notar el comportamiento de pila.

El mtodo main llama al mtodo factorial envindole un '3', luego este manda a llamar al mtodo factorial envindole un '2', luego este se vuelve a llamar

con un '1', y este manda a llamarse de nuevo con un '0', como en la condicin del algoritmo dice que cuando sea '0' el nmero, que regrese entonces,

termina el mtodo factorial(0), y se regresa al factorial(1), luego este termina y regresa al factorial(2), este termina y regresa a factorial(3), este termina y

regresa al mtodo main de donde fue llamado originalmente.




Si tenemos un cdigo de esta forma: void metodo4(){ //cdigo metodo5(); //cdigo } void mtodo2(){ //cdigo metodo3(); //cdigo } void metodo1(){ //cdigo metodo2(); //cdigo metodo4(); } void main(){ //cdigo metodo1(); //cdigo metodo6(); //cdigo }

Primero se llama al mtodo main(), luego este llama al metodo1(), luego este manda a llamar al metodo2(), y este manda a llamar a metodo3(),

metodo3() termina y regresamos a metodo2(), metodo2() termina y regresamos a metodo1(), metodo1() manda a llamar a metodo4(),

metodo4() manda a llamar a metodo5(), luego metodo5() termina y regresamos a metodo4(), luego regresamos a metodo1() y metodo1()

termina, regresamos a main(), luego manda a llamar a metodo6(), metodo6() termina y luego regresamos al main().




El Heap de memoria trabaja de forma distinta, este siempre va a crecer, En el Heap de memoria se guardan los objetos y arreglos que se declaran en un programa, cuando queremos crear un objeto en el mtodo donde esta declarado tenemos su instancia, su puntero o en otras palabras su direccin de memoria es contenida en la instancia, y el objeto en si, esta en el Heap. class Objeto{ int a; int b; } public static void main(){ Objeto obj1 = new Objeto(); Objeto obj2 = new Objeto(); } Por lo general el espacio de memoria del Heap va a ser mucho mayor que el del Stack pues va a contener todos los objetos y arreglos. Como podemos ver el mtodo main en el Stack va a tener cierto espacio que ocupan las instancias declaradas en el, a este espacio se le llama mbito del mtodo. En el mbito del mtodo main() tenemos las direcciones de memoria de los objetos, tambin podemos ver que los objetos ocupan un espacio en el Heap de memoria, por consiguiente, tambin tienen un mbito en el cual existen. Si cada instancia y cada entero ocupara una unidad de memoria, el tamao del mtodo main seria '2' y el tamao del objeto en el Heap seria de tamao '2'. Si tuviramos un cdigo de esta forma: public void masMemoria(){ Objeto obj1 = new Objeto(); } public static void main(){ Objeto obj1 = new Objeto; masMemoria(); }




Podemos ver que el mbito del mtodo main() es de tamao '1' y del mtodo masMemoria() tambin es tamao '1', y he aqu el porque pueden haber nombres de variables repetidas entre los mtodos, porque sus mbitos son distintos, las declaraciones estn separadas por los mbitos, en este caso, uno en el main() y otro en el mtodo masMemoria(). Los objetos no son los mismos pues estn tambin con sus propios mbitos y en distintos lugares en el Heap. En lenguajes de programacin orientada a objetos como Java se trabajan TODOS los objetos y arreglos como referencia, es decir, TODAS las declaraciones de objetos y arreglos son punteros. Cdigo en C/C++ Objeto * obj; Es equivalente a decir en Java Objeto obj; El contenido de esta variable es una direccin de memoria. Si tenemos este cdigo Objeto obj1 = new Objeto(); Objeto obj2 = new Objeto(); Objeto obj3; Podemos ver que obj1 y obj2 esta apuntando en un lugar en el Heap. Este es un lugar donde el objeto se esta alojando, para poder acceder al objeto usamos la referencia que tenemos en el mbito del mtodo main. Tambin podemos notar que obj3 no esta apuntando a ni un lugar, la razn es porque no se uso el operador new para direccionar y reservar memoria para su objeto. Ahora bien, que pasa si tenemos esta lnea de cdigo: obj3 = obj2; Como vemos en la grfica, obj3 ahora esta apuntando hacia obj2 pues copi su direccin de memoria, ahora se puede acceder a obj2 por medio de obj3.




Ahora bien, que pasa si tenemos el siguiente cdigo obj2 = obj1; Ahora obj2 copio la direccin de memoria de obj1, ahora obj1 puede ser modificado desde obj2, pero... que paso con el objeto donde estaba apuntando obj2 anteriormente? Ahora solo puede ser accedido por obj3. Pero que pasa si tenemos el siguiente cdigo obj3 = null;

Pero antes, que es null? Null es un valor especial que especifica que una referencia esta apuntando a nada. Pero... que paso con el objeto a donde se estaba apuntando anteriormente? Este objeto simplemente se perdi, y no puede ser accesado desde ni un lado del programa, pues nadie esta apuntando hacia el. Pero, que pasa con la memoria que este ocupaba?, esta tambin se perdi y no se puede recuperar, esta marcada como ocupada y no puede usarse para crear o colocar nuevos objetos. A este fenmeno de prdida de memoria se le llama Fuga de memoria o Memory Leak en ingles, este problema se soluciona con una buena administracin de memoria por parte del programador si se hace manualmente, mediante mtodos constructores y destructores (que se vern mas adelante).

Ahora con los nuevos lenguajes de programacin se implementa lo que se llama Recolectores de basura o Garbage Collector en ingles, lo que hace es poner a disposicin estos bloques perdidos o compactar la memoria para poder usarla mas tarde en el transcurso de la ejecucin del programa.

stack heap

Documents