Head First Design Pattern: 4 of 10

I just learnt my fourth design from the Head First Design Pattern book. Today, I learnt about the Singleton pattern.

According to Head First Design Patterns, the Singleton pattern is a pattern that is used to ensure a class has only one instance, and provides a global point of access to it.

For example, the singleton pattern can be implemented in Java like this

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

In order to ensure the Singleton class only has one instance, It's constructor is marked as private. Singleton has an API called getInstance().

The Singleton pattern seems like a very simple pattern but there are some gotchas you need to be aware of when it comes to using the Singleton pattern and multithreading. In a multithreaded code, it is possible to create multiple instances of the class above since multiple thread can have access to the getInstance function at the same time.
There are many ways to fix this:

1: Refactor the code above to use synchronised keyword.

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {
    }

    public static synchronised Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

By adding the synchronised keyboard to the getInstance() we are forcing every thread to wait it's turn before they enter the function. So only one thread can access the getInstance() function.

2: Simply use the Object keyword from Kotlin. Kotlin has the Singleton pattern built into the language with the Object keyword.

object Singleton {
}

If you need to have on instance of a class, for example, loggers, analytics, crash reporting. You should use the Singleton pattern