# 本实例主要介绍单例模式# 1.什么是单例模式  # 1. 确保有且只有一个对象被创建  # 2. 为对象提供一个访问点,以使程序可以全局访问该对象  # 3. 控制共享资源的并行访问# 2.单例模式实例class Singleton(object):	def __new__(cls):		if not hasattr(cls, 'instance'):			cls.instance = super(Singleton, cls).__new__(cls)		return cls.instances = Singleton()print("Object created",s)s1 = Singleton()print("Object created",s1)				# 3.单例设计模式中的懒汉式实例化class Singleton1:	__instance = None	def __init__(self):		if not Singleton1.__instance:			print("__init__ method called")		else:			print("Instance already created", self.getInstance())		@classmethod	def getInstance(cls):		if not cls.__instance:			cls.__instance = Singleton1()		return cls.__instances = Singleton1()print("Object created", Singleton1.getInstance())s1 = Singleton1()	# 4.Monostate(Borg) 单态模式# 所有对象共享相同状态,改变一个实例的状态,另一个实例也会改变class Borg:	__shared_state = {"1":"2"}	def __init__(self):		self.x = 1		self.__dict__ = self.__shared_state		passb = Borg()b1 = Borg()b.x = 4print("Borg object b", b)print("Borg object b1", b1)print("Object state b", b.__dict__)print("Object state b1", b1.__dict__)# 基于__new__方法本身实现Borgclass BorgNew:	__shared_state = {}	def __new__(cls, *args, **kwargs):		obj = super(BorgNew , cls).__new__(cls, *args, **kwargs)		obj.__dict__ = cls.__shared_state		return objb = BorgNew()b1 = BorgNew()b.x = 4print("Borg object b", b)print("Borg object b1", b1)print("Object state b", b.__dict__)print("Object state b1", b1.__dict__)			# 5.单例和元类# 元类: 元类是一个类的类,这意味着该类是它元类的一个实例class MyInt(type):	def __call__(cls, *args, **kwargs):		print("******Here is MyInt******",args)		print("How 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 = yi = int(4, 5)# 基于元类的单例实现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):	passlogger1 = Logger()logger2 = Logger()print(logger1, logger2)	# 6.单例模式的应用		# A. 数据库的操作import sqlite3class 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 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.cursorobjdb1 = Database().connect()db2 = Database().connect()print("Database objcursor db1", db1)print("Database objcursor db2", db2)# 单一的应用可以使用该方法,节约CPU,内存等资源# 集群化应用, 就需要使用数据库连接池	# B.监控服务class HealthCheck:	_instances = None	def __new__(cls, *args, **kwargs):		if not HealthCheck._instances:			HealthCheck._instances = super(HealthCheck, cls).__new__(cls, *args, **kwargs)		return HealthCheck._instances		def __init__(self):		self._servers = []		def addServer(self):		self._servers.append("server1")		self._servers.append("server2")		self._servers.append("server3")		self._servers.append("server4")		def changeServer(self):		self._servers.pop()		self._servers.append("server5")hc1 = HealthCheck()hc2 = HealthCheck()print(hc1,hc2)hc1.addServer()for i in range(4):	print("checking ", hc1._servers[i])hc2.changeServer()for i in range(4):	print("checking ", hc2._servers[i])								# 7.单例模式的优缺点# 优点: 1. 创建有且只有一个对象, 2.节省CPU,内存资源.# 缺点: 1. 全局变量被误改, 但是别的对象还在引用 2.同一个对象,创建多个引用 3.可能影响其他类