单例模式的python实现

# 本实例主要介绍单例模式
# 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.instance

s = 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.__instance

s = 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
		pass

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

print("Borg object b", b)
print("Borg object b1", b1)
print("Object state b", b.__dict__)
print("Object state b1", b1.__dict__)

# 基于__new__方法本身实现Borg
class BorgNew:
	__shared_state = {}
	def __new__(cls, *args, **kwargs):
		obj = super(BorgNew , cls).__new__(cls, *args, **kwargs)
		obj.__dict__ = cls.__shared_state
		return obj

b = BorgNew()
b1 = BorgNew()
b.x = 4

print("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 = y

i = 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):
	pass

logger1 = Logger()
logger2 = Logger()
print(logger1, logger2)
	

# 6.单例模式的应用		
# A. 数据库的操作
import sqlite3
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 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 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.可能影响其他类
单例模式的python实现

猜你喜欢
