Rethinking the Singleton: Beyond Global State in Python

Prerequisites

To follow this guide, you should understand Python classes, dunder methods like __new__ and __call__, and basic concurrency concepts involving the threading module.

Key Libraries & Tools

• threading: A built-in Python module used to demonstrate and solve race conditions in instance creation.
• Metaclasses: A deep-level Python feature used to create generic, reusable singleton logic.

Code Walkthrough

The Metaclass Approach

Using a metaclass is the most robust way to implement a singleton. By overriding __call__, we intercept the class instantiation process.

class SingletonMeta(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        return cls._instances[cls]

class DatabaseConfig(metaclass=SingletonMeta):
    def __init__(self):
        self.url = "sqlite:///dev.db"

Here, SingletonMeta maintains a dictionary of instances. When you call DatabaseConfig(), Python checks the dictionary first. If the instance exists, it returns it; otherwise, it creates one.

Making it Thread-Safe

In multi-threaded apps, two threads might check the dictionary simultaneously, creating two separate instances. We solve this with a double-checked locking pattern.

import threading

class SafeSingletonMeta(type):
    _instances = {}
    _lock = threading.Lock()
    def __call__(cls, *args, **kwargs):
        with cls._lock:
            if cls not in cls._instances:
                instance = super().__call__(*args, **kwargs)
                cls._instances[cls] = instance
        return cls._instances[cls]

Syntax Notes

• new vs call: Overriding __new__ handles instantiation at the class level, while __call__ on a metaclass handles the "calling" of the class itself.
• Modules as Singletons: In Python, a module is only initialized once per execution. For simple global state, a dedicated .py file is more idiomatic than a class-based singleton.

Practical Examples

Controlled instantiation is perfect for Lazy Loading. Imagine loading a massive Large Language Model. You don't want to load it at startup—only when the first prediction occurs.

class ModelLoader(metaclass=SingletonMeta):
    def __init__(self):
        print("Loading 10GB Model...") # Only runs once
        self.model = "Heavy Object"

Tips & Gotchas

• Testing Nightmare: Singletons create hidden dependencies. If a test modifies a singleton's state, every subsequent test inherits that change. Always provide a way to reset state for unit tests.
• Private Constructors: Unlike Java, Python cannot truly hide a constructor. Developers can always bypass your singleton logic by calling __new__ directly.