Implementing Thread‑Safe Singleton Pattern in Python

The Singleton pattern ensures that a class has only one instance throughout a program, which is useful for shared resources such as configuration objects.

Python offers several ways to implement a singleton:

Using a module (modules are naturally singletons because they are loaded once).

Using a decorator that caches the created instance.

Using a class with a class‑method that stores the instance.

Based on the __new__ method to control object creation.

Using a metaclass that overrides __call__ to return a single instance.

Module‑level singleton example:

<code class="language-python"># mysingleton.py
class Singleton(object):
    def foo(self):
        pass
singleton = Singleton()
</code>

Import and use the singleton directly:

<code class="language-python">from mysingleton import singleton
</code>

Decorator‑based singleton:

<code class="language-python">def Singleton(cls):
    _instance = {}
    def _singleton(*args, **kargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kargs)
        return _instance[cls]
    return _singleton

@Singleton
class A(object):
    a = 1
    def __init__(self, x=0):
        self.x = x
</code>

When multithreading is involved, the basic class‑method implementation can create multiple instances. Adding a lock solves this:

<code class="language-python">import time, threading

class Singleton(object):
    _instance_lock = threading.Lock()
    def __init__(self):
        time.sleep(1)
    @classmethod
    def instance(cls, *args, **kwargs):
        with Singleton._instance_lock:
            if not hasattr(cls, "_instance"):
                cls._instance = cls(*args, **kwargs)
        return cls._instance
</code>

Running multiple threads that call Singleton.instance() now prints the same object address, confirming thread‑safety.

__new__‑based singleton (thread‑safe):

<code class="language-python">import threading

class Singleton(object):
    _instance_lock = threading.Lock()
    def __init__(self):
        pass
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            with cls._instance_lock:
                if not hasattr(cls, "_instance"):
                    cls._instance = object.__new__(cls)
        return cls._instance
</code>

Instantiating Singleton() repeatedly returns the same object, even across threads.

Metaclass‑based singleton:

<code class="language-python">import threading

class SingletonType(type):
    _instance_lock = threading.Lock()
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            with SingletonType._instance_lock:
                if not hasattr(cls, "_instance"):
                    cls._instance = super(SingletonType, cls).__call__(*args, **kwargs)
        return cls._instance

class Foo(metaclass=SingletonType):
    def __init__(self, name):
        self.name = name
</code>

Both Foo('a') and Foo('b') refer to the same instance.

Overall, the article provides a comprehensive guide to creating singletons in Python and demonstrates how to make them safe for concurrent execution.