Java Memory Handling

In the following code, numberObj and memoryTest are created on the heap while in the stack there are the references to them.

package education.jtrainer;

public class MemoryTest1 {

        public static void main(String[] args) { 
            int number=10; // this is created in the Stack
            Integer numberObj=new Integer(10); // this is created in the Heap,  numberObj reference is kept in the stack
            MemoryTest1 memoryTest = new MemoryTest1(); // this is created in the Heap, mem reference is kept in the stack
            memoryTest.print(numberObj); // a block in the top of the stack is created to be used by print(numberObj) method. Since Java is pass by value, a new reference to Object is created in the print(numberObj) stack block 
            // at this point stack memory block allocated for print(numberObj) in stack becomes free.
            // at this point stack memory block created for main() method is destroyed. Also the program ends at this line, hence Java Runtime frees all the memory and end the execution of the program.
        }
         
        private void print(Integer param) { //param is a reference to an object on the heap
            System.out.println(param);
        }
    }

The picture below shows how the memory is allocated.

Figure 1: stack memory vs heap memory

Heap memory is divided into Young-Generation, Old-Generation or Tenured Generation, and Permanent Generation.

The Young Generation is where all new objects are allocated and aged. It includes the Eden zone and two Survivor Memory spaces S1 and S2

The Old Generation is used to store long surviving objects. Typically, a threshold is set for young generation object and when that age is met, the object gets moved to the old generation.

The Permanent generation contains metadata required by the JVM to describe the classes and methods used in the application. The permanent generation is populated by the JVM at runtime based on classes in use by the application. In addition, Java SE library classes and methods may be stored here. Classes may get collected (unloaded) if the JVM finds they are no longer needed and space may be needed for other classes.

Figure 2: heap memory areas

Why Java creators decided to split memory among 5 regions?

JRE has a process, called Garbage Collector (GC) running in the background that looks into all the objects in the memory and performs a marking process where garbage collector identifies which objects are in use (a reference to the object still exists) and which ones are not in use (a reference to the object do not exists anymore). This is not efficient because most of the newly created objects will become unused very soon and objects that are in-use for multiple garbage collection cycle are most likely to be in-use for future cycles too. This is the reason that Java Garbage Collection process is generational and we have Young Generation and Old Generation spaces in the heap memory. Java Garbage Collection can be minor (Minor GC) when Collecting garbage from Young space (consisting of Eden and Survivor spaces). Major GC is when cleaning the Old Generation. Full GC is when cleaning the entire Heap – both Young and Old Generation spaces.

Objects that are survived after many cycles of GC, are moved to the Old generation memory space. Usually it’s done by setting a threshold for the age of the young generation objects before they become eligible to promote to Old generation.

Let’s look at this process with the following java code, as usual the comments make the code self-explained

package education.jtrainer;

import java.util.ArrayList;

public class MemoryTest2 {

        ArrayList<byte[]> arrayHeap= new ArrayList<>();
        public static void main(String[] args) throws InterruptedException { 
            //Thread.sleep(60000);
            System.out.println("*****************MAIN METHOD STARTED*****************");
            MemoryTest2 MemoryTest=new MemoryTest2();
            for (int i=0; i<100000;i++) {
                MemoryTest.FillTheHeap();
                System.out.println("Heap filled with " + MemoryTest.arrayHeap.size()/10.0 +" Mbytes");    
                
            }
            System.out.println("*****************MEMORY TEST FINISHED*****************");
            
        }
        
        private void FillTheHeap() {
            byte[] numberObj=new byte[1000000]; // numberObj is a 1Mbyte array created in the Heap,  numberObj reference is kept in the stack
            arrayHeap.add(numberObj); //arrayHeap is referenced int he stack but the item of the list are in the heap
            try {
                Thread.sleep(100); //this is done for visualization purposes in VisualGC
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

If we start the above main method in the JVM using the followings parameters:

-Xms100M -> this is the initial heap size, it includes Eden, S1, S2, old generation (100 Mbytes)

-Xmx200M -> this is the maximum heap size, it includes Eden, S1, S2, old generation (200 Mbytes)

-Xmn30M -> this is Eden plus S1 and S2 size (30 Mbytes)

To see memory and GC operations in Graphical way, we can use jvusualvm tool which is part of JDK, so you don’t need to download it separately. Just run jvisualvm command in the terminal to launch the Java VisualVM application. Once launched, you need to install Visual GC plugin from Tools -< Plugins option

Once started, the following video shows what happens in the JVM memory: