Java Stack and Heap:tutorial de asignación de memoria de Java

¿Qué es la memoria de pila?

Stack en Java es una sección de memoria que contiene métodos, variables locales y variables de referencia. Siempre se hace referencia a la memoria de pila en el orden Último en entrar, primero en salir. Las variables locales se crean en la pila.

¿Qué es la memoria de pila?

Heap es una sección de memoria que contiene objetos y también puede contener variables de referencia. Las variables de instancia se crean en el montón

Asignación de memoria en Java

Asignación de memoria en Java es el proceso en el que las secciones de memoria virtual se reservan en un programa para almacenar las variables e instancias de estructuras y clases. Sin embargo, la memoria no se asigna a un objeto en la declaración, sino que solo se crea una referencia. Para la asignación de memoria del objeto, se usa el método new(), por lo que al objeto siempre se le asigna memoria en el montón.

La asignación de memoria de Java se divide en las siguientes secciones:

1. Montón
2. Apilar
3. Código
4. Estático

Esta división de la memoria es necesaria para su gestión eficaz.

• El código contiene su código de bytes .
• La pila La sección de memoria contiene métodos, variables locales y variables de referencia.
• El montón la sección contiene Objetos (también puede contener variables de referencia).
• La estática La sección contiene datos/métodos estáticos .

Diferencia entre variable local y de instancia

Variable de instancia se declara dentro de una clase pero no dentro de un método

class Student{ 
int num; // num is  instance variable 
public void showData{}

Variable local se declaran dentro un método que incluye método argumentos .

public void sum(int a){

int x = int a +  3;

// a , x are local variables;

}

Diferencia entre pila y montón

Haga clic aquí si no se puede acceder al video

Tomemos un ejemplo para entender esto mejor.

Considere que su método principal llama al método m1

public void m1{
int x=20
}

En la pila java, se creará un marco a partir del método m1.

La variable X en m1 también se creará en el marco para m1 en la pila. (Ver imagen a continuación).

El método m1 está llamando al método m2. En la pila java, se crea un nuevo marco para m2 encima del marco m1.

Las variables b y c también se crearán en un marco m2 en una pila.

public void m2(int b){
boolean c;
}

El mismo método m2 está llamando al método m3. Nuevamente, se crea un marco m3 en la parte superior de la pila (ver imagen a continuación).

Ahora digamos que nuestro método m3 está creando un objeto para la clase "Cuenta", que tiene dos instancias variables int p e int q.

Account {
             Int p;
             Int q;
       }

Aquí está el código para el método m3

public void m3(){
	Account ref = new Account();
	// more code
}

La declaración new Account() creará un objeto de cuenta en el montón.

La variable de referencia "ref" se creará en una pila java.

El operador de asignación "=" creará una variable de referencia para apuntar al objeto en el Heap.

Una vez que el método ha completado su ejecución. El flujo de control volverá al método de llamada. Que en este caso es el método m2.

La pila del método m3 se eliminará.

Dado que la variable de referencia ya no apuntará al objeto en el montón, sería elegible para la recolección de elementos no utilizados.

Una vez que el método m2 ha completado su ejecución. Se sacará de la pila y todas sus variables se eliminarán y ya no estarán disponibles para su uso.

Lo mismo para el método m1.

Eventualmente, el flujo de control regresará al punto de inicio del programa. Que por lo general, es el método "principal".

¿Qué pasa si Object tiene una referencia como su variable de instancia?

public static void main(String args[]) {
  A parent = new A(); //more code } class A{ B child = new B(); int e; //more code } class B{ int c; int d;  //more code }

En este caso, la variable de referencia "hijo" se creará en el montón, que a su vez apuntará a su objeto, algo como el diagrama que se muestra a continuación.

Resumen:

• Cuando se llama a un método, se crea un marco en la parte superior de la pila.
• Una vez que un método ha completado la ejecución, el flujo de control vuelve al método de llamada y se vacía su marco de pila correspondiente.
• Las variables locales se crean en la pila
• Las variables de instancia se crean en el montón y son parte del objeto al que pertenecen.
• Las variables de referencia se crean en la pila.