一、单例模式介绍

• 概念：单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供访问该实例的全局访问点。

• 功能：单例模式的主要功能是确保在应用程序中只有一个实例存在。

• 优势：

  1. 节省系统资源：由于只有一个实例存在，因此系统的资源占用会比较小。
  2. 更好的控制全局变量：单例模式可以有效控制全局变量的使用方式，从而更好地维护程序的可维护性和可扩展性。
  3. 更好的共享资源：由于只有一个实例存在，因此可以更好地共享资源。

• 劣势：

  1. 单例模式可能会引起代码耦合：由于单例模式只能创建一个实例，因此在程序中可能会出现过度依赖单例模式的情况，这会导致代码的耦合度变高。
  2. 单例模式可能会导致性能问题：如果单例模式的实例化过程比较复杂，可能会导致性能问题。

• 应用场景：

  1. 日志处理器：在应用程序中，只需要一个日志处理器来记录所有的日志信息。
  2. 数据库连接池：在应用程序中，只需要一个数据库连接池来管理所有的数据库连接。
  3. 全局配置信息：在应用程序中，只需要一个配置信息实例来管理所有的全局配置信息。

总之，单例模式适用于那些需要确保在应用程序中只有一个实例存在的情况，同时需要节省系统资源并且更好地控制全局变量。但同时，我们也需要注意单例模式可能引起的代码耦合和性能问题。

二、单例模实现原理

实现步骤

Python单例模式的实现原理基本与其编语言的单例模式实现原理相同。实现步骤如下：

1. 定义一个类变量，用于存储单例实例
2. 在初始化方法中，检查类变量是否已经被赋值。如果没有，则创建一个新的实例，并将其赋值给类变量。如果已经有一个实例在类变量中，则返回该实例
3. 提供一个静态方法来返回类变量中保存的单例实例

具体来说，单例模式的实现步骤如下：

class Singleton:
    __instance = None

    def __init__(self):
        if Singleton.__instance is None:
            Singleton.__instance = self
        else:
            raise Exception("Singleton class instantiated more than once")

    @staticmethod
    def get_instance():
        if not Singleton.__instance:
            Singleton()
        return Singleton.__instance

在上面的代码中，我们定义了一个类变量__instance来保存单例实例，我们通过构造函数__init__来检查该实例是否已经存在。如果不存在，则创建一个新的实例。如果已经存在，则抛出一个异常，防止创建多个实例。

我们还实现了一个静态方法get_instance，该方法返回类变量__instance保存的单例实例。在调用该方法时，我们首先检查类变量__instance是否存在，如果不存在，则创建一个新的实例。否则，我们只返回保存在类变量__instance中的实例。

以下是使用上述代码的示例：

s1 = Singleton.get_instance()
s2 = Singleton.get_instance()

assert s1 == s2     # s1 and s2 are equal

由于Singleton模式确保一个类只有一个实例，因此s1和s2应该是相等的。由于它们都是同一个实例，所以它们应该返回True。

静态方法介绍

@staticmethod是Python中的一个装饰器（decorator），它表明该方法是一个静态方法。静态方法是一个与类相关的函数，不依赖于类中的任何实例，因此静态方法可以在不创建类的实例的情况下调用。静态方法可以在类中使用，也可以在类外部使用。

静态方法使用@staticmethod装饰器来声明。例如：

class MyClass:
    @staticmethod
    def my_static_method():
        print("This is a static method")

在上面的代码中，我们定义了一个MyClass类，并使用@staticmethod装饰器来声明静态方法my_static_method()。在类的实例中，我们可以通过以下方式调用该方法：

my_instance = MyClass()
my_instance.my_static_method()

或者，我们也可以在类外部直接调用该方法：

MyClass.my_static_method()

请注意，与其他编程语言不同，Python中的静态方法可以访问类变量，但不能访问实例变量。

@staticmethod是一个装饰器（decorator），用于声明一个静态方法。静态方法是属于类的方法，而不是属于类的实例的方法。使用@staticmethod装饰器可以使方法不依赖于任何类实例而被调用。

静态方法可以在不需要实例化类的情况下进行调用。在静态方法中，不能访问类中的实例变量或实例方法。如果需要访问类中的属性或方法，则应该使用@classmethod装饰器声明一个类方法。

使用静态方法的主要目的是将方法与类关联，而不是与类的实例关联。因此，在需要在类的实例之间共享方法时，静态方法非常有用。

以下是一个使用@staticmethod装饰器的例子：

class MyClass:
    @staticmethod
    def my_static_method():
        print("This is a static method")

在上面的代码中，我们定义了一个名为MyClass的类，并使用@staticmethod装饰器声明了一个名为my_static_method()的静态方法。我们可以在类的实例之间共享该方法，或者在类外部直接调用该方法。

my_instance = MyClass()
my_instance.my_static_method()

MyClass.my_static_method()

输出结果：

This is a static method
This is a static method

类的实例之间共享方法

在Python中，类的实例之间可以共享方法。这是因为Python中的方法是在类的级别定义的，而不是在实例级别定义的。因此，所有该类的实例都共享相同的方法。

以下是一个示例，其中两个类的实例共享一个简单的方法：

class MyClass:
    @staticmethod
    def my_static_method():
        print("This is a static method")

instance_1 = MyClass()
instance_2 = MyClass()

instance_1.my_static_method()
instance_2.my_static_method()

输出结果：

This is a static method
This is a static method

在上面的代码中，我们定义了一个名为MyClass的类，并使用@staticmethod装饰器声明了一个名为my_static_method()的静态方法。我们创建了两个MyClass的实例，并在它们之间共享该方法。

当我们在这两个实例上调用这个方法时，我们会发现它们都打印出了相同的消息，证明了这两个实例之间的方法是共享的。

三、示例

实现全局配置功能

单例模式可以用于实现全局配置信息功能，确保应用程序中的所有模块都使用相同的配置信息，避免冲突和不一致性。

以下是一个简单的示例，演示如何使用单例模式实现全局配置信息功能：

class Config:
    __instance = None
    __config_data = {'key1': 'value1', 'key2': 'value2'}

    def __new__(cls):
        if cls.__instance is None:
            cls.__instance = super().__new__(cls)
        return cls.__instance

    def get_config_value(self, key):
        return self.__config_data.get(key)

    def set_config_value(self, key, value):
        self.__config_data[key] = value

config1 = Config()
config2 = Config()

# Set a new config value using config1
config1.set_config_value('key1', 'new_value1')

# Get the config value using config2
print(config2.get_config_value('key1'))

在上面的代码中，我们定义了一个名为 Config 的单例类，并在这个类中定义了一个静态私有变量 __instance，以确保该类的实例只被创建一次。我们还定义了一个名为 __config_data 的私有字典变量，用于存储全局配置信息。

在类定义中，我们使用 __new__() 方法来返回单例实例。如果该类已经有了一个实例，那么以后再次调用 __new__() 方法就会返回这个实例，而不是创建一个新的实例。

我们还定义了两个实例方法，get_config_value() 和 set_config_value()，用于获取和设置配置信息。

在这个示例中，我们创建了两个 Config 类的实例 config1 和 config2。我们先使用 config1 对 key1 进行了设置，然后使用 config2 来获取 key1 的值。我们发现，尽管我们在 config1 对象上进行了更改，但是 config2 对象获取到的值仍然是 value1，证明了这两个实例共享相同的全局配置信息。

实现记录日志功能

假设我们有一个需要记录日志的应用程序，我们希望在整个应用程序中只有一个日志处理器实例，因为多个日志处理器实例会占用系统资源，导致程序运行缓慢。这时我们可以使用Python单例模式来确保应用程序中只有一个日志处理器实例。

具体实现如下：

class Logger:
    instance = None
    
    def __init__(self):
        if not Logger.instance:
            Logger.instance = self
        else:
            self.__dict__ = Logger.instance.__dict__
            
    def log(self, message):
        # 日志记录逻辑
        pass

在上面的代码中，我们使用了一个类变量instance来保存Singleton类的唯一实例。在每次创建Singleton对象时，我们首先检查类变量是否已经被赋值。如果没有，则创建一个新的实例，并将其赋值给类变量。如果已经有一个实例在类变量instance中，则返回该实例。这样，我们就保证了整个应用程序中只有一个Logger实例存在。

使用上述代码的例子：

logger1 = Logger()
logger2 = Logger()

assert logger1 == logger2

由于Singleton模式确保一个类只有一个实例，因此logger1和logger2应该是相等的。由于它们都是同一个实例，所以它们应该返回True。

class MyClass:
    @staticmethod # @staticmethod装饰器声明了一个名为my_static_method()的静态方法
    def my_static_method():
        print("This is a static method")

instance_1 = MyClass()
instance_2 = MyClass()

# 实例之间共享方法
# 实例1,2 共享了MyClass()类的my_static_method()方法
instance_1.my_static_method()
instance_2.my_static_method()


class Singleton:
    __instance = None

    def __init__(self):
        if Singleton.__instance is None:
            Singleton.__instance = self
        else:
            raise Exception("Singleton class instantiated more than once")

    @staticmethod
    def get_instance():
        if not Singleton.__instance:
            Singleton()
        return Singleton.__instance

s1 = Singleton.get_instance()
s2 = Singleton.get_instance()

assert s1 == s2     # s1 and s2 are equal


class Logger:
    instance = None

    def __init__(self):
        if not Logger.instance:
            Logger.instance = self
        else:
            self.__dict__ = Logger.instance.__dict__

    def log(self, message):
        # 日志记录逻辑
        # print(message)
        return message


logger1 = Logger()
logger2 = Logger()
print(logger1.log("log1"))

print(logger2.log("log2"))

# assert logger1 == logger2

#********************* python 单例模式实现全局配置信息功能
class Config:
    __instance = None
    __config_data = {'key1': 'value1', 'key2': 'value2'}

    def __new__(cls):
        if cls.__instance is None:
            cls.__instance = super().__new__(cls)
        return cls.__instance

    def get_config_value(self, key):
        return self.__config_data.get(key)

    def set_config_value(self, key, value):
        self.__config_data[key] = value

config1 = Config()
config2 = Config()

print(config2.get_config_value('key1'))

# Set a new config value using config1
config1.set_config_value('key1', 'new_value1') # 设置已有信息
config1.set_config_value('key3', 'new_value3') # 新增信息

# Get the config value using config2
print(config2.get_config_value('key1'))
print(config2.get_config_value('key2'))
print(config2.get_config_value('key3'))

运行结果：

This is a static method
This is a static method
log1
log2
value1
new_value1
value2
new_value3