The **singleton [design pattern](https://www.educative.io/answers/design-patterns-in-java)** is used to restrict a class to only one instance at a time. This restriction is achieved by changing the accessibility of the constructor to `private` so that a new instance cannot be created using that constructor from outside the class. The **[static](https://www.educative.io/answers/how-to-use-static-keyword-in-java) method** **`getInstance()`** (defined in the class) creates a new instance after checking if an instance already exists. If it does, the same instance is returned; otherwise, a new instance is created and returned. The **static variable** **`instance`** keeps track of the existing instance of the class.

In Python, the constructor is used to create instances; you do not need to use the `getInstance()` method.  However, an additional method `__new__()` is used along with the `__init__()` method to create and initialize an instance, respectively. ​

#include <iostream>

using namespace std;

class Singleton{
private:
    static Singleton* instance;
    
    Singleton(){
        cout << "New instance created!" << endl;
    }

public:
    static Singleton* getInstance(){
        // Check if an instance already exists:
        if(instance == nullptr)
            instance = new Singleton();  // Create a new instance
        
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

int main(){
    //  Private default constructor can't be accessed:
    //  Singleton* s = new Singleton();
    
    Singleton* s = Singleton::getInstance();
    Singleton* t = Singleton::getInstance();
    
    // Print address of where 's' and 't' point
    // to make sure that it is the same object:
    cout << "'s' points to: " << s << endl
    << "'t' points to: " << t << endl;
    
    return 0;
}


class Singleton {

	private static Singleton instance = null;
	private Singleton() {
		System.out.println("New instance created!");
	}

    // Define a private constructor:
	public static Singleton getInstance() {
        // Check if an instance exists:
		if(instance == null)
			instance = new Singleton();  // Create a new instance
		
		return instance;
	}
	
	public static void main(String[] args) {
		// Private constructor won't work:
		// Singleton s = new Singleton();
		
		Singleton s = Singleton.getInstance();
		Singleton t = Singleton.getInstance();
		
		// Print address of 's' and 't'
		System.out.println(s);
		System.out.println(t);
	}
}


Java

class Singleton(object):
    # Static instance variable:
    _instance = None

    def __init__(self, name):
        self.name = name

    def __new__(cls, name):
        # Check if an instance exists:
        if not cls._instance:
            print("New instance created!")

            # Create new instance:
            cls._instance = object.__new__(cls)
        
        return cls._instance


# Create instance with name "xyz":
m1 = Singleton("xyz")

# Get the same instance:
m2 = Singleton("xyz")

# Updates the name of the same object
# from "xyz" to "abc"
m3 = Singleton("abc")

# Check if m1, m2 and m3 are referencing the same object:
print("IDs of the three objects:\n", id(m1), id(m2), id(m3))
print("Names of the three objects:\n", m1.name, m2.name, m3.name)


Python

How to implement the singleton pattern

The singleton design pattern is used to restrict a class to only one instance at a time. This restriction is achieved by changing the accessibility of the constructor to private so that a new instance cannot be created using that constructor from outside the class. The static method getInstance() (defined in the class) creates a new instance after checking if an instance already exists. If it does, the same instance is returned; otherwise, a new instance is created and returned. The static variable instance keeps track of the existing instance of the class. In Python, the constructor is used to create instances; you do not need to use the getInstance() method.  However, an additional method __new__() is used along with the __init__() method to create and initialize an instance, respectively. ​ 

How to implement the singleton pattern

Implementation