Difference between stack and heap memory is common programming question asked by
beginners learning Java or any other programming language. Stack and heap
memory are two terms programmers starts hearing once they started programming
but without any clear and definite explanation. Lack of knowledge on what is heap in Java and what
is stack memory in Java, results in misconcepts related to stack and heap. To
add to this confusion, stack is also a data structure which is used to store
elements in LIFO(Last In First out) order and
available in Java API as java.util.Stack. In general both stack and heap
are part of memory, a program is allocated and used for different purposes.
Java program runs inside JVM which is launched as a process by "java" command.
Java also uses both stack and heap memory for different needs. In our last
article 10 points on Java heap space I
have touched base on Java heap space and in this article we will see difference
between stack and heap memory in Java.
Difference between Stack vs Heap in Java
Here are few differences between stack and heap memory in Java:
1) Main difference between heap and stack is that stack memory is used to
store local
variables and function call, while heap memory is used to store objects
in Java. No matter, where object is created in code e.g. as member
variable, local variable or class variable, they are always created inside heap space in
Java.
2) Each Thread
in Java has there own stack which can be specified using -Xss JVM
parameter, similarly you can also specify heap size of Java program using JVM
option -Xms and -Xmx where -Xms is
starting size of heap and -Xmx is maximum size of java heap. to learn more
about JVM options see my post 10
JVM option Java programmer should know.
3) If there is no memory left in stack for storing function call or local
variable, JVM will throw java.lang.StackOverFlowError, while if there is no
more heap space for creating object, JVM will throw java.lang.OutOfMemoryError:
Java Heap Space. Read more about how to deal with java.lang.OutOfMemoryError in my post 2
ways to solve OutOfMemoryError in Java.
4) If you are using Recursion,
on which method calls itself, You can quickly fill up stack memory. Another
difference between stack and heap is that size of stack memory is lot lesser
than size of heap memory in Java.
5) Variables stored in stacks are only visible to the owner Thread, while
objects created in heap are visible to all thread. In other words stack memory
is kind of private memory of Java Threads, while heap memory is shared among
all threads.
That's all on difference between Stack and Heap memory in Java. As
I said, It’s important to understand what is heap and what is stack in Java and
which kind of variables goes where, how you can run out of stack and heap
memory in Java etc. Let us know if you are familiar with any other difference
between stack and heap memory in java.
Other Java programming
Interview Questions from Javarevisited Blog
Posts
9 comments:
Thanks for this blogs. I hv one question GC will look in memory of Stack while it runs to collect memory ?
Good question Keul. I think Garbage collector only collect Heap memory. Since object is only created in heap and stack mostly contains local variable which gets wiped off once they lost scope.
Nice little refresher. Thanks for sharing it. :)
The stack contains only values for integral types and references to objects, which are always stored in the heap. Since it doesn't contain any objects itself, there would be nothing to garbage-collect.
For me it would be interesting to know where variables are stored that are references to objects. For example: I create a new Object:
foo = new Object()
The object itself is stored on the heap. But what about the reference to the object?
Like in C, you have the memory of the object and the pointer or reference to that memory:
foo = malloc(sizeof(Struc));
It wouldn't make much sense to store the reference on the heap, if the reference is a local variable or a parameter.
@nlotz i think not only integral type but all predefined data type or we can say primitive types and all method calls are stored in Stack..
"No matter, where object is created in code e.g. as member variable, local variable or class variable, they are always created inside heap space in Java."
This is inaccurate. Escape analysis was introduced in 6u14 and enabled by default in 6u23.
"The -XX:+DoEscapeAnalysis option directs HotSpot to look for objects that are created and referenced by a single thread within the scope of a method compilation. Allocation is omitted for such non-escaping objects, and their fields are treated as local variables, often residing in machine registers. Synchronization on non-escaping objects is also elided."
http://www.oracle.com/technetwork/java/javase/6u14-137039.html
"Escape analysis is supported and enabled by default in Java SE 6u23 and later."
http://docs.oracle.com/javase/7/docs/technotes/guides/vm/performance-enhancements-7.html
There's another great article about this topic here, and answers the questions above: http://www.itcsolutions.eu/2011/02/06/tutorial-java-8-understand-stack-and-heap/
I love this blog, I've learned a lot here, so no offense :)
Great Article.. Your blog is full of useful information
Post a Comment