Java (JVM) Memory Model

Java (JVM) Memory Model and Garbage Collection.

Java (JVM) Memory Model

As you can see in the above image, JVM memory is divided into separate parts. At broad level, JVM Heap memory is physically divided into two parts – Young Generation and Old Generation.

Young Generation

Young generation is the place where all the new objects are created. When young generation is filled, garbage collection is performed. This garbage collection is called Minor GC. Young Generation is divided into three parts – Eden Memory and two Survivor Memory spaces.

Important Points about Young Generation Spaces:

• Most of the newly created objects are located in the Eden memory space.
• When Eden space is filled with objects, Minor GC is performed and all the survivor objects are moved to one of the survivor spaces.
• Minor GC also checks the survivor objects and move them to the other survivor space. So at a time, one of the survivor space is always empty.
• 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.

Old Generation

Old Generation memory contains the objects that are long lived and survived after many rounds of Minor GC. Usually garbage collection is performed in Old Generation memory when it’s full. Old Generation Garbage Collection is called Major GC and usually takes longer time.

Stop the World Event

All the Garbage Collections are “Stop the World” events because all application threads are stopped until the operation completes.
Since Young generation keeps short-lived objects, Minor GC is very fast and the application doesn’t get affected by this.
However Major GC takes longer time because it checks all the live objects. Major GC should be minimized because it will make your application unresponsive for the garbage collection duration. So if you have a responsive application and there are a lot of Major Garbage Collection happening, you will notice timeout errors.
The duration taken by garbage collector depends on the strategy used for garbage collection. That’s why it’s necessary to monitor and tune the garbage collector to avoid timeouts in the highly responsive applications.

Permanent Generation

Permanent Generation or “Perm Gen” contains the application metadata required by the JVM to describe the classes and methods used in the application. Note that Perm Gen is not part of Java Heap memory.
Perm Gen is populated by JVM at runtime based on the classes used by the application. Perm Gen also contains Java SE library classes and methods. Perm Gen objects are garbage collected in a full garbage collection.

Method Area

Method Area is part of space in the Perm Gen and used to store class structure (runtime constants and static variables) and code for methods and constructors.

Memory Pool

Memory Pools are created by JVM memory managers to create a pool of immutable objects, if implementation supports it. String Pool is a good example of this kind of memory pool. Memory Pool can belong to Heap or Perm Gen, depending on the JVM memory manager implementation.

Runtime Constant Pool

Runtime constant pool is per-class runtime representation of constant pool in a class. It contains class runtime constants and static methods. Runtime constant pool is the part of method area.

Java Stack Memory

Java Stack memory is used for execution of a thread. They contain method specific values that are short-lived and references to other objects in the heap that are getting referred from the method.

Java Heap Memory Switches

Java provides a lot of memory switches that we can use to set the memory sizes and their ratios. Some of the commonly used memory switches are:

VM Switch	VM Switch Description
-Xms	For setting the initial heap size when JVM starts
-Xmx	For setting the maximum heap size.
-Xmn	For setting the size of the Young Generation, rest of the space goes for Old Generation.
-XX:PermGen	For setting the initial size of the Permanent Generation memory
-XX:MaxPermGen	For setting the maximum size of Perm Gen
-XX:SurvivorRatio	For providing ratio of Eden space and Survivor Space, for example if Young Generation size is 10m and VM switch is -XX:SurvivorRatio=2 then 5m will be reserved for Eden Space and 2.5m each for both the Survivor spaces. The default value is 8.
-XX:NewRatio	For providing ratio of old/new generation sizes. The default value is 2.

Most of the times, above options are sufficient, but if you want to check out other options too then please check JVM Options Official Page.

Java Garbage Collection

Java Garbage Collection is the process to identify and remove the unused objects from the memory and free space to be allocated to objects created in the future processing. One of the best feature of java programming language is the automatic garbage collection, unlike other programming languages such as C where memory allocation and deallocation is a manual process.
Garbage Collector is the program running in the background that looks into all the objects in the memory and find out objects that are not referenced by any part of the program. All these unreferenced objects are deleted and space is reclaimed for allocation to other objects.
One of the basic way of garbage collection involves three steps:

1. Marking: This is the first step where garbage collector identifies which objects are in use and which ones are not in use.
2. Normal Deletion: Garbage Collector removes the unused objects and reclaim the free space to be allocated to other objects.
3. Deletion with Compacting: For better performance, after deleting unused objects, all the survived objects can be moved to be together. This will increase the performance of allocation of memory to newer objects.

There are two problems with simple mark and delete approach.

1. First one is that it’s not efficient because most of the newly created objects will become unused
2. Secondly objects that are in-use for multiple garbage collection cycle are most likely to be in-use for future cycles too.

The above shortcomings with the simple approach is the reason that Java Garbage Collection is Generational and we have Young Generation and Old Generation spaces in the heap memory. I have already explained above how objects are scanned and moved from one generational space to another based on the Minor GC and Major GC.

Java Garbage Collection Types

There are five types of garbage collection types that we can use in our applications. We just need to use JVM switch to enable the garbage collection strategy for the application. Let’s look at each of them one by one.

1. Serial GC (-XX:+UseSerialGC): Serial GC uses the simple mark-sweep-compact approach for young and old generations garbage collection i.e Minor and Major GC. Serial GC is useful in client-machines such as our simple stand alone applications and machines with smaller CPU. It is good for small applications with low memory footprint.
2. Parallel GC (-XX:+UseParallelGC): Parallel GC is same as Serial GC except that is spawns N threads for young generation garbage collection where N is the number of CPU cores in the system. We can control the number of threads using -XX:ParallelGCThreads=n JVM option. Parallel Garbage Collector is also called throughput collector because it uses multiple CPUs to speed up the GC performance. Parallel GC uses single thread for Old Generation garbage collection.
3. Parallel Old GC (-XX:+UseParallelOldGC): This is same as Parallel GC except that it uses multiple threads for both Young Generation and Old Generation garbage collection.
4. Concurrent Mark Sweep (CMS) Collector (-XX:+UseConcMarkSweepGC): CMS Collector is also referred as concurrent low pause collector. It does the garbage collection for Old generation. CMS collector tries to minimize the pauses due to garbage collection by doing most of the garbage collection work concurrently with the application threads. CMS collector on young generation uses the same algorithm as that of the parallel collector. This garbage collector is suitable for responsive applications where we can’t afford longer pause times. We can limit the number of threads in CMS collector using -XX:ParallelCMSThreads=n JVM option.
5. G1 Garbage Collector (-XX:+UseG1GC): The Garbage First or G1 garbage collector is available from Java 7 and it’s long term goal is to replace the CMS collector. The G1 collector is a parallel, concurrent, and incrementally compacting low-pause garbage collector. Garbage First Collector doesn’t work like other collectors and there is no concept of Young and Old generation space. It divides the heap space into multiple equal-sized heap regions. When a garbage collection is invoked, it first collects the region with lesser live data, hence “Garbage First”. You can find more details about it at Garbage-First Collector Oracle Documentation.

Java Singleton Design Pattern

Singleton is one of the Gangs of Four Design patterns and comes in the Creational Design Pattern category. From the definition, it seems to be a very simple design pattern but when it comes to implementation, it comes with a lot of implementation concerns. The implementation of Singleton pattern has always been a controversial topic among developers. Here we will learn about Singleton design pattern principles, different ways to implement Singleton and some of the best practices for it’s usage.

Singleton Pattern

Singleton pattern restricts the instantiation of a class and ensures that only one instance of the class exists in the java virtual machine. The singleton class must provide a global access point to get the instance of the class. Singleton pattern is used for logging, drivers objects, caching and thread pool.

Singleton design pattern is also used in other design patterns like Abstract Factory, Builder, Prototype, Facade etc. Singleton design pattern is used in core java classes also, for example java.lang.Runtime, java.awt.Desktop.

Java Singleton Pattern

To implement Singleton pattern, we have different approaches but all of them have following common concepts.

• Private constructor to restrict instantiation of the class from other classes.
• Private static variable of the same class that is the only instance of the class.
• Public static method that returns the instance of the class, this is the global access point for outer world to get the instance of the singleton class.

In further sections, we will learn different approaches of Singleton pattern implementation and design concerns with the implementation.

1. Eager initialization
2. Static block initialization
3. Lazy Initialization
4. Thread Safe Singleton
5. Bill Pugh Singleton Implementation
6. Using Reflection to destroy Singleton Pattern
7. Enum Singleton
8. Serialization and Singleton

Eager initialization

In eager initialization, the instance of Singleton Class is created at the time of class loading, this is the easiest method to create a singleton class but it has a drawback that instance is created even though client application might not be using it.
Here is the implementation of static initialization singleton class.

EagerInitializedSingleton.java

1 2 3 4 5 6 7 8 9 10 11 12 13

package com.journaldev.singleton; public class EagerInitializedSingleton {           private static final EagerInitializedSingleton instance = new EagerInitializedSingleton();           //private constructor to avoid client applications to use constructor     private EagerInitializedSingleton(){}     public static EagerInitializedSingleton getInstance(){         return instance;     } }

If your singleton class is not using a lot of resources, this is the approach to use. But in most of the scenarios, Singleton classes are created for resources such as File System, Database connections etc and we should avoid the instantiation until unless client calls the getInstance method. Also this method doesn’t provide any options for exception handling.

Static block initialization

Static block initialization implementation is similar to eager initialization, except that instance of class is created in the static block that provides option for exception handling.

StaticBlockSingleton.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

package com.journaldev.singleton; public class StaticBlockSingleton {     private static StaticBlockSingleton instance;           private StaticBlockSingleton(){}           //static block initialization for exception handling     static{         try{             instance = new StaticBlockSingleton();         }catch(Exception e){             throw new RuntimeException("Exception occured in creating singleton instance");         }     }           public static StaticBlockSingleton getInstance(){         return instance;     } }

Both eager initialization and static block initialization creates the instance even before it’s being used and that is not the best practice to use. So in further sections, we will learn how to create Singleton class that supports lazy initialization.
Read: Java static

Lazy Initialization

Lazy initialization method to implement Singleton pattern creates the instance in the global access method. Here is the sample code for creating Singleton class with this approach.

LazyInitializedSingleton.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

package com.journaldev.singleton; public class LazyInitializedSingleton {     private static LazyInitializedSingleton instance;           private LazyInitializedSingleton(){}           public static LazyInitializedSingleton getInstance(){         if(instance == null){             instance = new LazyInitializedSingleton();         }         return instance;     } }

The above implementation works fine incase of single threaded environment but when it comes to multithreaded systems, it can cause issues if multiple threads are inside the if loop at the same time. It will destroy the singleton pattern and both threads will get the different instances of singleton class. In next section, we will see different ways to create a thread-safe singleton class.

Thread Safe Singleton

The easier way to create a thread-safe singleton class is to make the global access method synchronized, so that only one thread can execute this method at a time. General implementation of this approach is like the below class.

ThreadSafeSingleton.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

package com.journaldev.singleton; public class ThreadSafeSingleton {     private static ThreadSafeSingleton instance;           private ThreadSafeSingleton(){}           public static synchronized ThreadSafeSingleton getInstance(){         if(instance == null){             instance = new ThreadSafeSingleton();         }         return instance;     }       }

Above implementation works fine and provides thread-safety but it reduces the performance because of cost associated with the synchronized method, although we need it only for the first few threads who might create the separate instances (Read: Java Synchronization). To avoid this extra overhead every time, double checked locking principle is used. In this approach, the synchronized block is used inside the if condition with an additional check to ensure that only one instance of singleton class is created.

Below code snippet provides the double checked locking implementation.

1 2 3 4 5 6 7 8 9 10

public static ThreadSafeSingleton getInstanceUsingDoubleLocking(){     if(instance == null){         synchronized (ThreadSafeSingleton.class) {             if(instance == null){                 instance = new ThreadSafeSingleton();             }         }     }     return instance; }

Read: Thread Safe Singleton Class

Bill Pugh Singleton Implementation

Prior to Java 5, java memory model had a lot of issues and above approaches used to fail in certain scenarios where too many threads try to get the instance of the Singleton class simultaneously. So Bill Pugh came up with a different approach to create the Singleton class using a inner static helper class. The Bill Pugh Singleton implementation goes like this;

BillPughSingleton.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14

package com.journaldev.singleton; public class BillPughSingleton {     private BillPughSingleton(){}           private static class SingletonHelper{         private static final BillPughSingleton INSTANCE = new BillPughSingleton();     }           public static BillPughSingleton getInstance(){         return SingletonHelper.INSTANCE;     } }

Notice the private inner static class that contains the instance of the singleton class. When the singleton class is loaded, SingletonHelper class is not loaded into memory and only when someone calls the getInstance method, this class gets loaded and creates the Singleton class instance.
This is the most widely used approach for Singleton class as it doesn’t require synchronization. I am using this approach in many of my projects and it’s easy to understand and implement also.
Read: Java Nested Classes

Using Reflection to destroy Singleton Pattern

Reflection can be used to destroy all the above singleton implementation approaches. Let’s see this with an example class.

ReflectionSingletonTest.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

package com.journaldev.singleton; import java.lang.reflect.Constructor; public class ReflectionSingletonTest {     public static void main(String[] args) {         EagerInitializedSingleton instanceOne = EagerInitializedSingleton.getInstance();         EagerInitializedSingleton instanceTwo = null;         try {             Constructor[] constructors = EagerInitializedSingleton.class.getDeclaredConstructors();             for (Constructor constructor : constructors) {                 //Below code will destroy the singleton pattern                 constructor.setAccessible(true);                 instanceTwo = (EagerInitializedSingleton) constructor.newInstance();                 break;             }         } catch (Exception e) {             e.printStackTrace();         }         System.out.println(instanceOne.hashCode());         System.out.println(instanceTwo.hashCode());     } }

When you run the above test class, you will notice that hashCode of both the instances are not same that destroys the singleton pattern. Reflection is very powerful and used in a lot of frameworks like Spring and Hibernate, do check out Java Reflection Tutorial.

Enum Singleton

To overcome this situation with Reflection, Joshua Bloch suggests the use of Enum to implement Singleton design pattern as Java ensures that any enum value is instantiated only once in a Java program. Since Java Enum values are globally accessible, so is the singleton. The drawback is that the enum type is somewhat inflexible; for example, it does not allow lazy initialization.

EnumSingleton.java

1 2 3 4 5 6 7 8 9 10

package com.journaldev.singleton; public enum EnumSingleton {     INSTANCE;           public static void doSomething(){         //do something     } }

Read: Java Enum

Serialization and Singleton

Sometimes in distributed systems, we need to implement Serializable interface in Singleton class so that we can store it’s state in file system and retrieve it at later point of time. Here is a small singleton class that implements Serializable interface also.

SerializedSingleton.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

package com.journaldev.singleton; import java.io.Serializable; public class SerializedSingleton implements Serializable{     private static final long serialVersionUID = -7604766932017737115L;     private SerializedSingleton(){}           private static class SingletonHelper{         private static final SerializedSingleton instance = new SerializedSingleton();     }           public static SerializedSingleton getInstance(){         return SingletonHelper.instance;     }       }

The problem with above serialized singleton class is that whenever we deserialize it, it will create a new instance of the class. Let’s see it with a simple program.

SingletonSerializedTest.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

package com.journaldev.singleton; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectInputStream; import java.io.ObjectOutput; import java.io.ObjectOutputStream; public class SingletonSerializedTest {     public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {         SerializedSingleton instanceOne = SerializedSingleton.getInstance();         ObjectOutput out = new ObjectOutputStream(new FileOutputStream(                 "filename.ser"));         out.writeObject(instanceOne);         out.close();                   //deserailize from file to object         ObjectInput in = new ObjectInputStream(new FileInputStream(                 "filename.ser"));         SerializedSingleton instanceTwo = (SerializedSingleton) in.readObject();         in.close();                   System.out.println("instanceOne hashCode="+instanceOne.hashCode());         System.out.println("instanceTwo hashCode="+instanceTwo.hashCode());               } }

Output of the above program is;

1 2	instanceOne hashCode=2011117821 instanceTwo hashCode=109647522

So it destroys the singleton pattern, to overcome this scenario all we need to do it provide the implementation of readResolve() method.

1 2 3

protected Object readResolve() {     return getInstance(); }

After this you will notice that hashCode of both the instances are same in test program.
Read: Java Serialization and Java Deserialization.
I hope this article helps you in grasping fine details of Singleton design pattern, do let me know through your thoughts and comments.

3 ways to loop over Set or HashSet in Java

3 ways to loop over Set or HashSet in Java? Examples

Since Set interface or HashSet class doesn't provide a get() method to retrieve elements, the only way to take out elements from a Set is to iterate over it by using Iterator, or loop over Set using advanced for loop of Java 5. You can get the iterator by calling the iterator() method of Set interface. This method returns an iterator over the elements in the sets but they are returned in no particular order, as Set doesn't guarantee any order. Though individual Set implementations e.g. LinkedHashSet or TreeSet can impose ordering and in such iterator will return elements on that order. You can only traverse in one direction using iterator i.e. from first to last elements, there is no backward traversing allowed as was the case with List interface and ListIterator. Similarly, if you use advanced for loop, then also you can traverse in only one direction.

In this tutorial, you will learn both ways to traverse over Set or HashSet in Java i.e. by using both Iterator and enhanced for loop. Btw, Java 8 also introduced a new to loop over set, that is by using the forEach() method if you are lucky to be running on Java 8 then you can use that as well.

Iterating over Set using Iterator

Here are the steps to traverse over as Set using Iterator in Java:

1. Obtain the iterator by calling the iterator() method.
2. You can use while or for loop along with hasNext(), which return true if there are more elements in the Set.
3. Call the next() method to obtain the next elements from Set.

Iterator<String> itr = setOfStocks.iterator();

// traversing over HashSet
System.out.println("Traversing over Set using Iterator");
while(itr.hasNext()){
  System.out.println(itr.next());
}

Loop over HashSet using for loop

There are no particular steps to loop over Set using enhanced for loop, as you just need to use the Set as per loop construct as shown below:

for(String stock : setOfStocks){
   System.out.println(stock);
}

This will print all the stocks from the setOfStocks into the console.

Traversing over HashSet using forEach() method

This method is only available from Java 8 onwards. This forEach() method belongs to Iterable interface and since Set implements that you can use this to traverse over Set as shown below:

public class HashSetLooperJava8{

    public static void main(String args[]) {

        // Creating and initializing an HashSet for iteration
        Set<String> setOfBooks = new HashSet<>();
        setOfBooks.add("Effective Java");
        setOfBooks.add("Clean Code");
        setOfBooks.add("Refactoring");
        setOfBooks.add("Head First Java");
        setOfBooks.add("Clean Coder");
        
        // iterating over HashSet using forEach() method in Java 8
        setOfBooks.forEach(System.out::println);

    }

}

Output:
Clean Code
Effective Java
Head First Java
Clean Coder
Refactoring

There is another forEach() method defined in the Stream class from new JDK 8 Stream API, See 10 ways to use forEach in Java 8 for more examples.


Here is the summary of all three ways to iterate over HashSet or any Set in Java: