理解单例设计模式
只允许Singleton类生成一个实例。
如果已经有一个实例了，我们会重复提供同一个对象
|
1 2 3 4 5 6 7 8 9 10 11 12 |
class Singleton(object): def __new__(self): if not hasattr(self, 'instance'): self.instance = super(Singleton, self).__new__(self) return self.instance s = Singleton() print("Object created ", s) s1 = Singleton() print("Object created ", s1) |
懒汉式实例化
例如在导入模块的时候，我们可能会无意中创建一个对象，但当时根本用不到它。
懒汉式实例化能够确保在实际需要时寻创建对象。
所以，懒汉式实例化是一种节约资源并仅在需要时才创建它们的方式。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
class Singleton(object): __instance = None def __init__(self): if not Singleton.__instance: print("__init__method called..") else: print("Instance already created: ", self.getInstance()) @classmethod def getInstance(self): if not self.__instance: self.__instance = Singleton() return self.__instance s = Singleton() # 类已初始化，但未创建对象 print("Object created ", Singleton.getInstance()) # 在这里创建 s1 = Singleton() # 实例已创建 |
Monostate单(态)例模式（1）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
class Borg(object): __shared_state = {"1":"2"} def __init__(self): self.x = 1 self.__dict__ = self.__shared_state pass b = Borg() b1 = Borg() b.x = 4 print("Borg Object 'b': ", b) ## b和b1是不同的对象 print("Borg Object 'b1': ", b1) print("Object State 'b': ", b.__dict__) ## b和b1处于相同状态 print("Object State 'b1': ", b1.__dict__) |
Monostate单(态)例模式（2）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class Borg(object): _shared_state = {"1":"2"} def __new__(self, *args, **kwargs): obj = super(Borg, self).__new__(self, *args, **kwargs) obj.__dict__ = self._shared_state return obj b = Borg() b1 = Borg() print("Borg Object 'b': ", b) ## b和b1是不同的对象 print("Borg Object 'b1': ", b1) print("Object State 'b': ", b.__dict__) ## b和b1处于相同状态 print("Object State 'b1': ", b1.__dict__) |
单例和元类(1)
|
1 2 3 4 5 6 7 8 9 10 11 12 |
class MyInt(type): def __call__(self, *args, **kwds): print("***** Here's My int *****", args) print("Now do whatever you want with these objects...") return type.__call__(self, *args, **kwds) class int(metaclass=MyInt): def __init__(self, x, y): self.x = x self.y = y i = int(4, 5) |
单例和元类(2)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class MetaSingleton(type): _instances = {} def __call__(self, *args, **kwargs): if self not in self._instances: self._instances[self] = super(MetaSingleton, self).__call__(*args, **kwargs) return self._instances[self] class Logger(metaclass=MetaSingleton): pass logger1 = Logger() logger2 = Logger() print(logger1) print(logger2) |
单例模式 I
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
import sqlite3 class MetaSingleton(type): _instances = {} def __call__(self, *args, **kwargs): if self not in self._instances: self._instances[self] = super(MetaSingleton, self).__call__(*args, **kwargs) return self._instances[self] class Database(metaclass=MetaSingleton): connection = None def connect(self): if self.connection is None: self.connection = sqlite3.connect("db.sqlite3") self.cursorobj = self.connection.cursor() return self.cursorobj db1 = Database().connect() db2 = Database().connect() print("Database Objects DB1", db1) print("Database Objects DB2", db2) |
单例模式 II
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
class HealthCheck(object): _instance = None def __new__(self, *args, **kwargs): if not HealthCheck._instance: HealthCheck._instance = super(HealthCheck, self).__new__(self, *args, **kwargs) return HealthCheck._instance def __init__(self): self._servers = [] def addServer(self): self._servers.append("Server 1") self._servers.append("Server 2") self._servers.append("Server 3") self._servers.append("Server 4") def changeServer(self): self._servers.pop() self._servers.append("Server 5") hc1 = HealthCheck() hc2 = HealthCheck() hc1.addServer() print("Schedule health check for servers (1)..") for i in range(4): print("Checking ", hc1._servers[i]) hc2.changeServer() print("Schedule health check for servers (2)..") for i in range(4): print("Checking ", hc2._servers[i]) |
