Gestión de memoria en 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 la 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 Java La asignación de memoria 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.

• La código sección contiene su bytecode.
• La Apilar sección de memoria contiene métodos, variables locales y variables de referencia.
• La Montón la sección contiene Objetos (también puede contener variables de referencia).
• La 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 interior 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 este formulario. si el video no es accesible

Tomemos un ejemplo para entenderlo 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 de m1 en la pila. (Ver imagen a continuación).

El método m1 llama 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 llama 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 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.

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 montón.

Una vez que el método ha finalizado su ejecución, el flujo de control volverá al método que lo invocó, 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 basura.

Una vez que el método m2 haya completado su ejecución, se extraerá de la pila y todas sus variables se vaciarán y ya no estarán disponibles para su uso.

Lo mismo para el método m1.

Finalmente, el flujo de control regresará al punto de inicio del programa, que normalmente es 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.

¿Qué es la recolección de basura en Java?

Recolección de basura en Java Es un proceso mediante el cual los programas realizan la gestión de la memoria de forma automática. El recolector de basura (GC) encuentra los objetos no utilizados y los elimina para recuperar la memoria. En JavaLa asignación dinámica de memoria de objetos se logra utilizando el operador new que utiliza algo de memoria y la memoria permanece asignada hasta que haya referencias para el uso del objeto.

Cuando no hay referencias a un objeto, se supone que ya no es necesario y se puede recuperar la memoria ocupada por el objeto. No existe una necesidad explícita de destruir un objeto como Java maneja la desasignación automáticamente.

La técnica que logra esto se conoce como Recolección de basura. Los programas que no desasignan memoria pueden eventualmente fallar cuando no queda memoria en el sistema para asignar. Se dice que estos programas tienen pérdidas de memoria. Recolección de basura en Java sucede automáticamente durante la vida útil del programa, eliminando la necesidad de desasignar memoria y evitando así pérdidas de memoria.

En lenguaje C, es responsabilidad del programador desasignar la memoria asignada dinámicamente utilizando la función free(). Aquí es donde Java Guías de gestión de memoria.

Nota: Todos los objetos se crean en la sección Heap de la memoria. Más información sobre esto en un tutorial posterior.

Ejemplo: aprender el mecanismo del recolector de basura en Java

Paso 1) Copie el siguiente código en un editor.

class Student{
int a;
int b;
  public void setData(int c,int d){
    a=c;
    b=d;
  }
  public void showData(){
    System.out.println("Value of a = "+a);
    System.out.println("Value of b = "+b);
  }
  public static void main(String args[]){
    Student s1 = new Student();
    Student s2 = new Student();
    s1.setData(1,2);
    s2.setData(3,4);
    s1.showData();
    s2.showData();
    //Student s3;
    //s3=s2;
    //s3.showData();
    //s2=null;
    //s3.showData();
    //s3=null;
    //s3.showData();
  }
}

Paso 2) Guarde, compile y ejecute el código. Como se muestra en el diagrama, se crean dos objetos y dos variables de referencia.

Paso 3) Descomentar la línea # 20,21,22. Guarde, compile y ejecute el código.

Paso 4) Como se muestra en el diagrama siguiente, dos variables de referencia apuntan al mismo objeto.

Paso 5) Descomente las líneas n.° 23 y 24. Compile, guarde y ejecute el código

Paso 6) Como se muestra en el diagrama siguiente, s2 se vuelve nulo, pero s3 todavía apunta al objeto y no es elegible para la recolección de basura de Java.

Paso 7) Descomente las líneas n.° 25 y 26. Guarde, compile y ejecute el código

Paso 8) En este punto, no hay referencias que apunten al objeto y pasa a ser elegible para la recolección de basura. Se eliminará de la memoria y no habrá forma de recuperarlo.

Cómo eliminar un objeto en Java?

1) Si desea que su objeto sea elegible para la recolección de basura, asigne su variable de referencia a nula.

2) Los tipos primitivos no son objetos. No se les puede asignar nulos.

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.