单例模式的不同形式

机制

确保类有且只有一个特定类型的对象，并提供全局访问点。这样做的原因是因为我们访问单一资源(例如打印机和数据库操作)时，防止发生访问冲突的现象。

实现

使构造函数私有化，并创建一个静态方法来完成对象的初始化。这样，对象在第一次调用时创建。此后，该类将返回同一个对象。

代码实现

class Singleton(object):
    """覆盖__new__方法来控制对象的创建，对象s就是通过__new__方法创建的
    方法hasattr用于查看对象cls是否具有属性instance,该属性的作用是检查该类是否已经生成了一个类
    当s1被请求的时候，hasattr发现对象已经存在，所以将s1分配到已有的对象地址
    """
    def __new__(cls):  
        if not hasattr(cls, 'instance'):        
            cls.instance = super(Singleton, cls).__new__(cls)
        return cls.instance


s = Singleton()
print(s)
s1 = Singleton()
print(s1)



<__main__.Singleton object at 0x01B69890>
<__main__.Singleton object at 0x01B69890>

懒汉式实例化

# 在导入模块的时候，我们可能无意中创建一个对象，但当时用不到
# 懒汉式实例化是一种节约资源并仅在需要时才创建它们的方式

class Singleton:
    __instance = None

    def __init__(self):
        if not Singleton.__instance:
            print("__init__ method called")
        else:
            print('Instance already created:', self.getInstance())

    @classmethod
    def getInstance(cls):
        if not cls.__instance:
            cls.__instance = Singleton()
        return cls.__instance


s = Singleton()
# print(s)
print("object created", Singleton.getInstance())
s1 = Singleton()



__init__ method called
__init__ method called
object created <__main__.Singleton object at 0x016998D0>
Instance already created: <__main__.Singleton object at 0x016998D0>

模块级别的单例模式

# GoF的单例设计模式指的是一个类有且只有一个对象，然而根据Alex Martelli的说法，
# 通常程序员需要的时侯让实例共享相同的状态。开发人员应该关注状态和行为，
# 而不是同一性。由于该概念基于所有对象共享相同的状态，因此也被称为Monostate(单态)模式
# 意指：只是共享变量，而不是共享对象
# 实际上生成的每个实例的地址都是不一样的，这里的实例可以理解为指向类的一个快捷指针

class Borg:
    __shared_state = {'1': '2'}

    def __init__(base):
        base.x = 1
        base.__dict__ = base.__shared_state
        pass


b = Borg()
b1 = Borg()
b.x = 4
print(b, '\n', b1, '\n', b.__dict__, '\n', b1.__dict__)



<__main__.Borg object at 0x01F7FDD0> 
 <__main__.Borg object at 0x01F7FE30> 
 {'1': '2', 'x': 4} 
 {'1': '2', 'x': 4}


# 改写__new__方法实现Borg
class Borg(object):
    _shared_state = {}

    def __new__(cls, *args, **kwargs):
        obj = super(Borg, cls).__new__(cls, *args, **kwargs)
        obj.__dict__ = cls._shared_state
        return obj


obj = Borg()
obj1 = Borg()
obj.x = 2
obj1.y = 3
print(obj.__dict__)
print(obj1.__dict__)


{'x': 2, 'y': 3}
{'x': 2, 'y': 3}