单例设计模式多种实现方式

1、什么是单例：

1.1、 确保类有且只有一个对象被创建
1.2、为对象提供一个访问点，以使程序可以全局访问对象
1.3、控制共享资源的并行访问

2、经典单例模式

2.1、只允许Singleton类生成一个实例
2.2、如果已经有了一个实例对象，就重复提供同一个对象

class Singleton():
    def __new__(cls, *args, **kwargs):
        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 0x000002081ED3B438>
<__main__.Singleton object at 0x000002081ED3B438>	

3、单例模式下的懒汉式实例化

3.1、懒汉实例化是一种节约资源并在需要的时候创建
3.2、需要实例化的时候通过getInstance方法进行实例化

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('Object created:', Singleton.getInstance())
s1 = Singleton()

输出结果：

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

4、Monostate单例模式

4.1、基于所有对象共享相同状态
4.2、可以创建多个实例化对象

第一种实现：
class Borg():
__shared_status = {‘1’: ‘2’}

def __init__(self):
    self.x = 1
    self.__dict__ = self.__shared_status
    pass


b = Borg()
b1 = Borg()
b.x = 5

print("Borg Object 'b':", b)
print("Borg Object 'b1':", b1)
print("Borg Status 'b':", b.__dict__)
print("Borg Status 'b1':", b1.__dict__)

输出结果：

Borg Object 'b': <__main__.Borg object at 0x000001CDE6678518>
Borg Object 'b1': <__main__.Borg object at 0x000001CDE681FB00>
Borg Status 'b': {'1': '2', 'x': 5}
Borg Status 'b1': {'1': '2', 'x': 5}

第二种实现：

class Borg():
    __shared_state = {}

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


b = Borg()
b1 = Borg()
b.x = 5
b1.y = 4

print("Borg Object 'b':", b)
print("Borg Object 'b1':", b1)
print("Borg Status 'b':", b.__dict__)
print("Borg Status 'b1':", b1.__dict__)

输出结果：

Borg Object 'b': <__main__.Borg object at 0x000001F7EAC98518>
Borg Object 'b1': <__main__.Borg object at 0x000001F7EAE3FAC8>
Borg Status 'b': {'x': 5, 'y': 4}
Borg Status 'b1': {'x': 5, 'y': 4}

5、单例和元类

5.1、元类

元类是一个类的类，这意味着该类是它的元类的实例
元类控制着对象的实例化

5.2 元类的实现

class MyInt(type):
    def __call__(cls, *args, **kwargs):
        print("***** Here is My int *****", args)
        print("Now do whatever you want with these objects..")
        return type.__call__(cls, *args, **kwargs)


class Int(metaclass=MyInt):
    def __init__(self, x, y):
        self.x = x
        self.y = y


i = Int(4,5)

输出结果：

***** Here is My int ***** (4, 5)
Now do whatever you want with these objects..

5.3、元类的单例实现

class MetaSingleton(type):
    __instances = {}

def __call__(cls, *args, **kwargs):
    if cls not in cls.__instances:
        cls.__instances[cls] = super(MetaSingleton, cls).__call__(*args, **kwargs)
    return cls.__instances[cls]


class Logger(metaclass=MetaSingleton):
    pass


logger = Logger()
logger1 = Logger()
print(logger, logger1)

输出结果：

<__main__.Logger object at 0x00000227702589E8> 
<__main__.Logger object at 0x00000227702589E8>

6、单例模式的缺点

由于单例模式具有全局的访问权限，因此可能会出现
以下一些问题：
6.1、全局变量可能再某处被误改，但是开发人员仍然认为他们没有发生变化，而该变量还在应用程序的其他应用被使用。
6.2、可能会对同一对象创建多个引用。由于单例只会创建一个对象，因此这种情况下会对同一个对象创建多个引用。
6.3、所有依赖于全局变量的类都会由于一个类的改变而紧密耦合为全局数据，从而可能在无意中影响另一个类。