python单例模式代码-单例模式的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.可能影响其他类