Heap vs Stack vs Perm Space

Question

• ¿Cuáles son las diferencias entre los espacios de memoria Java (Perm Space, Space Stack, Heap Space)?
• ¿Cuándo utiliza la JVM una u otra?
• Si uso Scala/Groovy/etc., ¿Hay diferencias?

Answer 1

Simplemente

• espacio de almacenamiento dinámico: Todos los objetos se asignan en vivo aquí.
• Espacio de pila: Almacena las referencias al objeto para la variable en llamada de método o instanciación de variable.
• espacio Perm: Tiendas cargado clases de información

Por ejemplo:

Student std = new Student(); 

después de ejecutar la línea anterior estado de la memoria serán así.

• Montón: tiendas "nuevo estudiante()"
• Stack: almacena información sobre "std"
• Perm Espacio: almacena información acerca de la clase Estudiante

Answer 2

Perdóname por la adición de una respuesta a una pregunta tan antigua: la respuesta actual es excelente, pero se pierde un par de casos extremos debido al código estático y las actualizaciones de Java 8.

general

• Pila
  • asignados por hilo
  • Tiendas referencias locales y primitivas
  • Esto está en el ámbito de memoria - Cuando un método o extremos de hilo, todos sus datos en el la pila se ha perdido
  • Tiene el acceso más rápido, por lo que una primitiva local es más rápida para usted se que un objeto local
• Montón
  • existen todas las instancias de objetos asignados aquí
  • Dividido en generaciones, con la generación más joven es el primer lugar de GC se ve
  • Disponible para todos los hilos para las asignaciones y las desasignaciones se deben sincronizar
  • Esta memoria se puede fragmentar (pero generalmente no se administra esto usted mismo)
• PermGen Código
  • Stores información de clase cargado
  • Almacena información inmutable (Primatives, internados cuerdas)
  • Tiendas clase estática members

Ejemplo

public class SimpleVal { //The Class (loaded by a classloader) is in the PermGen 

    private static final int MAGIC_CONSTANT = 42; //Static fields are stored in PermGen 
    private static final SimpleVal INSTANCE = new SimpleVal(1); //Static field objects are created in the heap normally, with the reference in the PermGen ('class statics' moved to the heap from Java 7+) 
    private static SimpleVal previousInstance; //Mutable static fields also have their reference in PermGen so they can easily cause memory leaks 

    private int value; //Member variables will be part of the heap 

    public SimpleVal(int realValue) { 
     value = realValue; 
     ... 
    } 

    public static int subtract(SimpleVal val1, SimpleVal val2) { 
     .... 
    } 

    public int add(SimpleVal other) { //Only one copy of any method (static or not) exists - in PermGen 
     int sum = value + other.value; //Local values in methods are placed in the Stack memory 
     return sum; 
    } 

} 

public static void main(String[] args) { 

    SimpleVal val1 = null; 
    SimpleVal val2 = new SimpleVal(3); //Both of these variables (references) are stored in the Stack 

    val1 = new SimpleVal(14); //The actual objects we create and add to the variables are placed in the Heap (app global memory, initially in the Young Gen space and later moved to old generation, unless they are very large they can immediately go old gen) 

    int prim = val1.add(val2); //primitive value is stored directly in the Stack memory 
    Integer boxed = new Integer(prim); //but the boxed object will be in the heap (with a reference (variable) in the Stack) 

    String message = "The output is: "; //In Java 7+ the string is created in the heap, in 6 and below it is created in the PermGen 
    System.out.println(message + prim); 

} 

Java 8 Nota: espacio PermGen fue reemplazado con lo que se llama metaespacio. Esto sigue funcionando igual pero puede redimensionarse automáticamente: de forma predeterminada, Metaspace auto aumenta su tamaño en la memoria nativa hasta un máximo (especificado en los parámetros JVM), pero PermGen siempre tiene un tamaño máximo fijo contiguo a la memoria Heap.

Android Note: De Android 4.0 (de 3.0 en la práctica) Android debería cumplir con los contratos de memoria descritos, pero en versiones anteriores el implementation was broken. La memoria 'Stack' en Android-Davlik está de hecho basada en el registro (los tamaños de las instrucciones y los recuentos varían entre los dos, pero para un desarrollador la funcionalidad sigue siendo la misma).

Por último, para obtener más información sobre la mejor respuesta que he visto a este tema en StackOverflow es here