{"id":13554,"date":"2017-09-05T11:21:58","date_gmt":"2017-09-05T16:21:58","guid":{"rendered":"https:\/\/stackify.com\/?p=13554"},"modified":"2023-03-18T11:13:46","modified_gmt":"2023-03-18T11:13:46","slug":"java-heap-vs-stack","status":"publish","type":"post","link":"https:\/\/stackify.com\/java-heap-vs-stack\/","title":{"rendered":"Java Heap Space vs. Stack Memory: How Java Applications Allocate Memory"},"content":{"rendered":"

Java applications need a certain amount of RAM on a computer to run. Each time an object or variable is declared, it needs more RAM. Simply designating enough memory to hold every value declared and run each method would lead to a bloated application.<\/p>\n

To keep application memory requirements lean, it is partitioned in ways that require less memory and allows the application to run more quickly.<\/p>\n

The Java Virtual Machine (JVM) divides memory between Java Heap Space and Java Stack Memory in a way that only uses memory that\u2019s needed.<\/p>\n

What is Java Heap Space<\/h3>\n

It is created by the Java Virtual Machine when it starts. The memory is used as long as the application is running. Java runtime uses it to allocate memory to objects and Java Runtime Environment (JRE) classes<\/a>.<\/p>\n

When an object is created, it is always created in Heap and has global access. That means all objects can be referenced from anywhere in the application.<\/p>\n

It is managed by two concepts: Garbage collection<\/a> and young-generation, old-generation.<\/p>\n

Garbage collection<\/a> works to free memory by clearing any by objects without any references in the methods. These are objects that are no longer being used. Clearing them ensures they don\u2019t take up space in the Heap.<\/p>\n

Young-generation, old-generation helps prioritize objects for garbage collection by dividing Java Heap Space into two generations.<\/p>\n

The nursery is the younger generation where the new objects are stored. When the nursery is full, garbage collection cleans it out. Note only the memory space for the nursery is full. There is still memory in the old generation.<\/p>\n

The old generation is home to objects have been around long enough. When the old generation runs out of room, garbage collection removes the objects not being used in the old space. Again, only part of the Heap is full when old garbage collection happens. There is still room in the nursery.<\/p>\n

What is Java Stack Memory?<\/h3>\n

This is the temporary memory where variable values are stored when their methods are invoked. After the method is finished, the memory containing those values is cleared to make room for new methods.<\/p>\n

When a new method is invoked, a new block of memory will be created in the Stack. This new block will store the temporary values invoked by the method and references to objects stored in the Heap that are being used by the method.<\/p>\n

Any values in this block are only accessible by the current method and will not exist once it ends.<\/p>\n

When the method ends, that block will be erased. The next method invoked will use that empty block.<\/p>\n

This \u201clast in, first out\u201d method makes it easy to find the values needed and allows fast access to those values.<\/p>\n

How They’re Used in a Java Application<\/h3>\n

Let\u2019s look at a very simple example of a Java application to see how memory is allocated.<\/p>\n

package com.journaldev.test;package com.journaldev.test;\npublic class Memory {\n public static void main(String[] args) { \/\/ Line 1 int i=1; \/\/ Line 2 Object obj = new Object(); \/\/ Line 3 Memory mem = new Memory(); \/\/ Line 4 mem.foo(obj); \/\/ Line 5 } \/\/ Line 9\n private void foo(Object param) { \/\/ Line 6 String str = param.toString(); \/\/\/\/ Line 7 System.out.println(str); } \/\/ Line 8\n}<\/pre>\n
In the above example from JournalDev.com<\/a>, the use of Stack and Heap is explained as follows:<\/p>\n