Python design pattern: Singleton pattern

Preface

The singleton pattern Maybe the simplest design pattern , Singletons are very generic objects . Allows you to guarantee that a class has only one instance ,  And provide a global node to access the instance .

We can think of the captain of a ship as a real-life example of the singleton model . On board , He is in charge . He is responsible for important decisions , Because of this responsibility , He received some requests .

As mentioned earlier , One use case of the singleton pattern is to create a single object that maintains the global state of the program . Other possible use cases are as follows ：

• Control concurrent access to shared resources ; for example , Object classes that manage connections to databases

• Horizontal services or resources , Because it can be accessed from different parts of the application or by different users to complete its work ; for example , Japan Log recording system Or utility The core class

class Singleton: """Definition of a Singleton object.""" singleton_instance = None def __init__(self): """ Override the initialization mechanism, returning only the single instance. """ ... @staticmethod def get_singleton(): """ Method for fetching the Singleton instance. Is static so that it can be accessed everywhere. """ ... @staticmethod def update_singleton(val): """ Method for setting value of Singleton instance. Is static so that it can be accessed everywhere. """ ...

Stored in Singleton The data in the instance is arbitrary . It is important to , Regardless of the data , What about the caller and the range ,Singleton Object will return the same instance . This makes the unit useful in implementing things such as global settings or run configuration .

Single example

Use the following code snippet to play Active Singleton Realization . Try using data structures （ For example, a dictionary ） Replace variable Singleton_instance, And look at Getter and Setter How to change the implementation of . Try writing some shares Singleton Function of instance .

class Singleton: """Definition of a Singleton object.""" # Maintain state of Singleton singleton_instance = None def __init__(self): """Override the initialization mechanism.""" if Singleton.singleton_instance is None: Singleton.singleton_instance = self @staticmethod def get_singleton(): """ Method for fetching the Singleton instance. Is static so that it can be accessed everywhere. """ if Singleton.singleton_instance is None: Singleton() # Call __init__ to initialize instance return Singleton.singleton_instance @staticmethod def update_singleton(val): """ Method for setting value of Singleton instance. Is static so that it can be accessed everywhere. """ if Singleton.singleton_instance is None: Singleton() # Call __init__ to initialize instance Singleton.singleton_instance = valSingleton.update_singleton("Michael")print("Value in Singleton instance is: " + Singleton.get_singleton())Singleton() # Try to create a new Singleton instanceprint("Value in Singleton instance is STILL: " + Singleton.get_singleton())

The singleton pattern can also be implemented by making singleton classes use metaclasses （ Its type , Has a previously defined metaclass ） To achieve . According to need , Metaclass __call__() Method to ensure that only one instance of a class can be created ：

class SingletonMeta(type): """ The Singleton class can be implemented in different ways in Python. Some possible methods include: base class, decorator, metaclass. We will use the metaclass because it is best suited for this purpose. """ _instances = {} def __call__(cls, *args, **kwargs): """ Possible changes to the value of the `__init__` argument do not affect the returned instance. """ if cls not in cls._instances: instance = super().__call__(*args, **kwargs) cls._instances[cls] = instance return cls._instances[cls]class Singleton(metaclass=SingletonMeta): def some_business_logic(self): """ Finally, any singleton should define some business logic, which can be executed on its instance. """ # ...if __name__ == "__main__": # The client code. s1 = Singleton() s2 = Singleton() if id(s1) == id(s2): print("Singleton works, both variables contain the same instance.") else: print("Singleton failed, variables contain different instances.")

Advantages and disadvantages of singleton mode

advantage ：

•   You can guarantee that there is only one instance of a class .

•   You get a global access node to the instance .

•   Initialize singleton objects only when they are first requested .

shortcoming ：

• A violation of the Principle of single responsibility .  This model solves two problems at the same time .

•   Singleton patterns can mask bad design ,  For example, each component of the program knows too much about each other .

•   This mode needs special processing in multithreading environment ,  Avoid multiple threads creating singleton objects multiple times .

•   Unit testing of singleton client code can be difficult ,  Because many test frameworks create mock objects in an inheritance based way .  Because the constructor of the singleton class is private ,  And most languages can't override static methods ,  So you need to think of ways to simulate singletons carefully .  Or don't write test code at all ,  Or don't use singleton mode .

Reference link ：

• The singleton pattern