Where does class, object, reference variable get stored in Java. In heap or in stack? Where is heap or stack located?

Runtime data area in JVM can be divided as below,

1. Method Area : Storage area for compiled class files. (One per JVM instance)

2. Heap : Storage area for Objects. (One per JVM instance)

3. Java stack: Storage area for local variables, results of intermediate operations. (One per thread)

4. PC Register : Stores the address of the next instruction to be executed if the next instruction is native method then the value in pc register will be undefined. (One per thread)

5. Native method stacks : Helps in executing native methods (methods written in languages other than Java). (One per thread)

Following are points you need to consider about memory allocation in Java.

Note:

Object and Object references are different things.

1. There is new keyword in Java used very often to create a new object. But what new does is allocate memory for the object of class you are making and returns a reference. That means, whenever you create an object as static or local, it gets stored in heap.

2. All the class variable primitive or object references (which is just a pointer to location where object is stored i.e. heap) are also stored in heap.

3. Classes loaded by ClassLoader and static variables and static object references are stored in a special location in heap which permanent generation.

4. Local primitive variables, local object references and method parameters are stored in stack.

5. Local Functions (methods) are stored in stack but static functions (methods) goes in permanent storage.

6. All the information related to a class like name of the class, object arrays associated with the class, internal objects used by JVM (like Java/Lang/Object) and optimization information goes into the Permanent Generation area.

7. To understand stack, heap, data you should read about Processes and Process Control Block in Operating Systems.

All objects in Java are stored on the heap. The "variables" that hold references to them can be on the stack or they can be contained in other objects (then they are not really variables, but fields), which puts them on the heap also.

The Class objects that define Classes are also heap objects. They contain the bytecode that makes up the class (loaded from the class files), and metadata calculated from that.

The Stack section of memory contains methods, local variables and reference variables.

The Heap section contains Objects (may also contain reference variables).

after short google, I found a link to describe it, yes a youtube video link. ^_^

http://www.youtube.com/watch?v=VQ4eZw6eVtQ

The concept is quite simple :

1. Instance variables (primitive, Wrapper classes, references, objects (non-static)) - Heap
2. Local Variables , references - stack
3. Other data objects like : Class metadata, JVM code, static variables, static object references, static functions etc which earlier used to be in Permgen Space (till Java 7) are now being moved to Metaspace in JAVA 8.

PS : Metaspace is part of native memory, so no need to worry about OOM:Pergem Exeption now.

For more details : https://siddharthnawani.blogspot.com/

Local variables(method variables) + methods live on the stack. While Objects and their instance variable live on the heap.

Now, Reference variable can be local variable(if created inside method) or instance variable(if created inside class, but outside method). So reference variable can be anywhere, either stack or heap.

According to JVM Specification,

The classes and it's own constant pool, i.e static variables are stored in Method Area. Here class means nothing but bunch of fields, methods and constants, these methods are in the form of instructions are stored in Method Area and can be identified by an address.

Objects are nothing but a filled class template that will be created in Heap Area, but the object reference is created in Stack.

public class Sample{
int field;
static int constant;
public void test(){
int localVariable=10;
Sample samp=new Sample();
  }
}

In the example, sample.class will go to Method Area, that means 'field', 'constant' and method 'test' are allocated in Method Area.

When the execution is started, The object created by new Sample() will go to Heap but 'samp' is just a object reference which goes to stack and holds the address of object which is present in the Heap

For more information please check this link, JVM Specification

In Java, a variable can either hold an object reference (s in String s="OOO" holds the reference to the object "OOO") or a primitive value (i in int i=10 holds 10). These variables can either be on the heap or the stack, depending on whether they are local or not and which flavor of the JVM you are using.

In the Java Virtual Machine 8 specification document (https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html), the memory organization pertaining to this is as follows.

1. Every Java thread has its own JVM stack.

   It holds local variables and partial results, and plays a part in method invocation and return.

   There may be object references as well in the stack. The specification does not differentiate between a primitive variable and a reference variable as long as it is local. This stack is used using units of data called frames. However,

   Because the Java Virtual Machine stack is never manipulated directly except to push and pop frames, frames may be heap allocated.

   Therefore, it is upto the implementation of the JVM specification (like OpenJDK or Oracle), where the frames are located.

2. Every JVM instance has a heap. The heap is

   ... the run-time data area from which memory for all class instances and arrays is allocated.

   The actual memory holding the objects' data resides on the heap. The heap is shared among all the JVM's threads. This also includes object references which are part of objects ie instance variables.

   For example, take the following classes.

   class Moo{ private String string= "hello"; } class Spoo{ private Moo instanceReferenceVariable = new Moo(); public void poo(){ int localPrimitiveVariable=12; Set<String> localReferenceVariable = new HashSet<String>(); } }

   Here the object being referred to by the variable instanceReferenceVariable
   would be on the heap, and hence all the instance variables of this object, like string, will also be on the heap. Variables localPrimitiveVariable and localReferenceVariable will be on the stack.

3. Method Area: The method area is a restricted part of the heap which

   ... stores per-class structures such as the run-time constant pool, field and method data, and the code for methods and constructors, including the special methods used in class and instance initialization and interface initialization.

4. Run-time constant pool: This is a part of the method area.

Hope this was able to clarify things.