싱글턴(Singleton) 패턴 : 기초The Singleton Pattern: The Basics

Singleton

Even if the constructor is called multiple times, only one object is actually created, and constructors called after the first creation return the object created by the first one. ~ Wikipedia ~

The singleton pattern guarantees that only one instance of a given class is ever created across the whole program.

Why not just use a global variable?

The biggest reason to use the singleton pattern instead of a global variable is access control.

• Global variable: A global variable can be accessed and modified directly from anywhere in the application. That makes data integrity hard to guarantee and can cause bugs through unexpected changes.
• Singleton pattern: With the singleton pattern, you access the object through a method that controls how the instance is created and accessed. This gives you better control over the object’s state and lifecycle, and helps keep the data intact.

When should you use it?

Think of objects that have no reason to be created more than once. Typical cases include:

• Database connections
• Logging
• Configuration
• Caches

Implementing a singleton in Python

There are several ways to implement a singleton in Python. Here, we’ll implement it in five ways and look at the characteristics of each.

1. GoF(Gang of Four)
2. __new__
3. metaclass
4. Eager
5. Thread Safe

Singleton: GoF (Gang of Four)

Class diagram

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'primaryColor': '#2a3844',
      'lineColor': '#fff',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#fff'
    }
  }
}%%

classDiagram
    direction BT

    class Singleton{
        -_instance: Singleton

        +get_instance() Singleton
    }

Implementation

This is the most classic approach, the pattern as described by the GoF.

1. Override the __init__ method so it can’t be used.
2. Call the class method get_instance to create the instance, or return the one that already exists.

from typing import Self

class Singleton:
    _instance = None

    def __init__(self) -> None:
        raise RuntimeError("Call instance() method")

    @classmethod
    def get_instance(cls) -> Self:
        if not cls._instance: 
            cls._instance = super().__init__(cls)
        return cls._instance

from gof.singleton import Singleton

def test_gof_singleton():
    obj_1 = Singleton.get_instance()
    obj_2 = Singleton.get_instance()

    assert obj_1 is obj_2

Singleton: __new__

Class diagram

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'primaryColor': '#2a3844',
      'lineColor': '#fff',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#fff'
    }
  }
}%%

classDiagram
    direction BT

    class Singleton{
        -_instance: Singleton

        +__new__() Singleton
    }

Implementation

This is the most common way to implement it in Python.

1. Override the __new__ method.
2. In __new__, create the instance, or return the one that already exists.

from typing import Self

class Singleton:
    _instance = None

    def __new__(cls) -> Self:
        if not cls._instance:
            cls._instance = super().__new__(cls)

        return cls._instance

from new.singleton import Singleton

def test_new_singleton():
    obj_1 = Singleton()
    obj_2 = Singleton()

    assert obj_1 is obj_2

Singleton: metaclass

A metaclass is the class of a class. In other words, a metaclass is what creates classes. In Python, everything is an object, and classes are objects too. So the thing that creates a class is itself an object, and that’s what we call a metaclass.

There are two main ways to create a custom metaclass:

1. Inherit from type to make a metaclass and override its methods
2. Use type to create classes dynamically

Class diagram

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'primaryColor': '#2a3844',
      'lineColor': '#fff',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#fff'
    }
  }
}%%

classDiagram
    direction BT

    class SingletonMeta{
        - _instances: dict

        - __call__() Singleton
    }

    class Singleton{
        + some_business_logic()
    }

    Singleton --|> SingletonMeta

Implementation

You can build the singleton pattern by creating a metaclass that inherits from type.

1. Define a metaclass that inherits from type.
2. Override the __call__ method.
3. Set the metaclass on the class you want to make a singleton.

import logging

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        logging.info("metaclass __call__")

        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        
        return cls._instances.get(cls)

from meta.meta import SingletonMeta

class Singleton(metaclass=SingletonMeta):
    def some_business_logic(self):
        ...

from meta.singleton import Singleton

def test_meta_singleton():
    obj_1 = Singleton()
    obj_2 = Singleton()

    assert obj_1 is obj_2

Think of metaclass= as naming the class that steps into the creation process of this class. Here, because we overrode the __call__ method, the SingletonMeta metaclass’s __call__ method is called at the moment the object is created.

INFO     root:singleton_meta.py:8 metaclass __call__
INFO     root:singleton_meta.py:8 metaclass __call__

Whereas the earlier singletons implement the pattern inside the class itself, a metaclass lets you write the code in an inheritance style. That helps you write more object-oriented code.

Wrapping up

So far, we’ve covered the basic concept of the singleton pattern and three ways to implement it in Python. 😊

• The traditional GoF-style implementation
• An implementation using Python’s __new__ method
• An object-oriented implementation using a metaclass

Each implementation has its own characteristics. The GoF approach is the most traditional yet intuitive, and the __new__ approach allows a Pythonic implementation. The metaclass approach has the advantage of letting you write highly reusable code through inheritance.

What’s next

In The Singleton Pattern: Advanced, we’ll cover the remaining two implementations in detail: Eager Initialization and a Thread Safe singleton. In particular, we’ll take an in-depth look at how to implement a singleton safely in a multithreaded environment.