Pila y montón de Java: tutorial de asignación de memoria de Java

¿Qué es la memoria de pila?

La pila 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 orden "Último en entrar, primero en salir". Las variables locales se crean en la pila.

¿Qué es la memoria del montón?

El montón 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 el momento de la declaración, sino que solo se crea una referencia. Para la asignación de memoria del objeto, se utiliza 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 lo siguientewing 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 sección contiene su bytecode.
  • El Apilar 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).
  • El Estático la sección contiene Datos/métodos estáticos.

Diferencia entre variable local y de instancia

Instancia variable 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 son declarados dentro a 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 el video no es accesible

Pongamos 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.

Pila y montón de Java

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

Pila y montón de Java

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

Pila y montón de Java

Pila y montón de Java

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

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

Pila y montón de Java

El mismo método m2 llama al método m3. Nuevamente se crea un marco m3 en la parte superior de la pila (vea la imagen a continuación).

Pila y montón de Java

Pila y montón de Java

Ahora digamos que nuestro método m3 está creando un objeto para la clase "Cuenta", que tiene dos variables de instancias int p y 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.

Pila y montón de Java

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

Pila y montón de Java

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

Pila y montón de Java

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.

Pila y montón de Java

La pila del método m3 se eliminará.

Pila y montón de Java

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

Pila y montón de Java

Una vez que el método m2 haya 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 ocurre con el método m1.

Finalmente, el flujo de control volverá al punto de inicio del programa. Que suele ser el método “principal”.

¿Qué pasa si el objeto tiene una referencia como 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 "niño" se creará en el montón, que a su vez apuntará a su objeto, algo parecido al diagrama que se muestra a continuación.

Pila y montón de Java

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 regresa al método que lo llamó 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.