Python 单例模式 详解
阅读目录
- 单例模式
- 概念
- 优点
- 单例模式的实现
- 使用模块 （常用）
- 基于 类 实现
- 基于__new__实现的单例模式（最常用）
- 基于metaclass(元类)实现的单例模式
- metaclass（元类）详解
- 装饰器 实现的单例模式
- 单例模式的应用
- 单例模式的应用（在数据库连接池中用到单例模式）
单例模式
概念
"""
单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。
当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。
如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，
这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。
事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。
"""
优点
当类只有一个实例而且客户可以从一个众所周知的访问点访问它时
比如：数据库链接、Socket创建链接
'''
对唯一实例的受控访问
单利相当于全局变量，但防止了命名空间被污染
与单利模式功能相似的概念：全局变量、静态变量（方法）
那为什么用单例模式，不用全局变量呢？
因为：全局变量可能会有名称空间的干扰，如果有重名的可能会被覆盖
'''
单例模式的实现
使用模块 （常用）
# 文件导入的形式
"""
Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，
就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，
就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做：
"""
# s1.py 文件中
class Foo(object):
def test(self):
print("123")
v = Foo()
# v是Foo的实例
------
# s2.py 文件中
from s1 import v as v1
print(v1,id(v1)) # 35788560
from s1 import v as v2
print(v1,id(v2)) # 35788560
# 两个的内存地址是一样的
# 文件加载的时候，第一次导入后，再次导入时不会再重新加载。
基于 类 实现
# ======================单例模式：无法支持多线程情况===============
class Singleton(object):
def __init__(self):
import time
time.sleep(1)
@classmethod
def instance(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
Singleton._instance = Singleton(*args, **kwargs)
return Singleton._instance
import threading
def task(arg):
obj = Singleton.instance()
print(obj)
for i in range(10):
t = threading.Thread(target=task,args=[i,])
t.start()
'''
# 打印结果内存地址不一样，没有实现单例
<__main__.Singleton object at 0x000001FC58CFC5F8>
<__main__.Singleton object at 0x000001FC58B72470>
<__main__.Singleton object at 0x000001FC58CFC6D8>
<__main__.Singleton object at 0x000001FC58D03048>
<__main__.Singleton object at 0x000001FC58D3FDD8>
<__main__.Singleton object at 0x000001FC58D40208>
<__main__.Singleton object at 0x000001FC58D407B8>
<__main__.Singleton object at 0x000001FC58D401D0>
<__main__.Singleton object at 0x000001FC58D4A3C8>
<__main__.Singleton object at 0x000001FC58D4A2E8>
'''
# ====================单例模式：支持多线程情况================、
import time
import threading
class Singleton(object):
_instance_lock = threading.Lock()
def __init__(self):
time.sleep(1)
@classmethod
def instance(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
with Singleton._instance_lock: # 为了保证线程安全在内部加锁
if not hasattr(Singleton, "_instance"):
Singleton._instance = Singleton(*args, **kwargs)
return Singleton._instance
# 加锁！未加锁部分并发执行,加锁部分串行执行,速度降低,但是保证了数据安全
def task(arg):
obj = Singleton.instance()
print(obj)
for i in range(10):
t = threading.Thread(target=task,args=[i,])
t.start()
time.sleep(20)
obj = Singleton.instance()
print(obj)
# 使用先说明，以后用单例模式，obj = Singleton.instance()
# 示例：
# obj1 = Singleton.instance()
# obj2 = Singleton.instance()
# print(obj1,obj2)
# 错误示例
# obj1 = Singleton()
# obj2 = Singleton()
# print(obj1,obj2)
'''
打印结果：
<__main__.Singleton object at 0x000001938A81A320>
<__main__.Singleton object at 0x000001938A81A320>
<__main__.Singleton object at 0x000001938A81A320>
<__main__.Singleton object at 0x000001938A81A320>
<__main__.Singleton object at 0x000001938A81A320>
<__main__.Singleton object at 0x000001938A81A320>
<__main__.Singleton object at 0x000001938A81A320>
<__main__.Singleton object at 0x000001938A81A320>
<__main__.Singleton object at 0x000001938A81A320>
<__main__.Singleton object at 0x000001938A81A320>
'''
基于__new__实现的单例模式（最常用）
'''
通过上面例子，当我们实现单例时，为了保证线程安全需要在内部加入锁
当我们实例化一个对象时，是先执行了类的__new__方法（我们没写时，默认调用object.__new__），
实例化对象；然后再执行类的__init__方法，对这个对象进行初始化，
所有我们可以基于这个，实现单例模式
'''
# =============单线程下执行===============
import threading
class Singleton(object):
_instance_lock = threading.Lock()
def __init__(self):
pass
def __new__(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
with Singleton._instance_lock:
if not hasattr(Singleton, "_instance"):
# 类加括号就回去执行__new__方法，__new__方法会创建一个类实例：Singleton()
Singleton._instance = object.__new__(cls) # 继承object类的__new__方法，类去调用方法，说明是函数，要手动传cls
return Singleton._instance #obj1
# 类加括号就会先去执行__new__方法，在执行__init__方法
# obj1 = Singleton()
# obj2 = Singleton()
# print(obj1,obj2)
# ===========多线程执行单利============
def task(arg):
obj = Singleton()
print(obj)
for i in range(10):
t = threading.Thread(target=task,args=[i,])
t.start()
# 使用先说明，以后用单例模式，obj = Singleton()
# 示例
# obj1 = Singleton()
# obj2 = Singleton()
# print(obj1,obj2)
'''
打印结果：
<__main__.Singleton object at 0x000001EBEF5E3E80>
<__main__.Singleton object at 0x000001EBEF5E3E80>
<__main__.Singleton object at 0x000001EBEF5E3E80>
<__main__.Singleton object at 0x000001EBEF5E3E80>
<__main__.Singleton object at 0x000001EBEF5E3E80>
<__main__.Singleton object at 0x000001EBEF5E3E80>
<__main__.Singleton object at 0x000001EBEF5E3E80>
<__main__.Singleton object at 0x000001EBEF5E3E80>
<__main__.Singleton object at 0x000001EBEF5E3E80>
<__main__.Singleton object at 0x000001EBEF5E3E80>
'''
基于metaclass(元类)实现的单例模式
"""
1.对象是类创建，创建对象时候类的__init__方法自动执行，
对象()执行类的 __call__ 方法
2.类是type创建，创建类时候type的__init__方法自动执行，
类() 执行type的 __call__方法(类的__new__方法,类的__init__方法)
# 第0步: 执行type的 __init__ 方法【类是type的对象】
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
pass
# 第1步: 执行type的 __call__ 方法
# 1.1 调用 Foo类（是type的对象）的 __new__方法，用于创建对象。
# 1.2 调用 Foo类（是type的对象）的 __init__方法，用于对对象初始化。
obj = Foo()
# 第2步：执行Foo的 __call__ 方法
obj()
"""
# ===========类的执行流程================
class SingletonType(type):
def __init__(self,*args,**kwargs):
print(self) # 会不会打印？ # metaclass（元类）详解
在Python3中继承type的就是元类
元类的示例：
# 方式一
class MyType(type):
'''继承type的就是元类'''
def __init__(self,*args,**kwargs):
print("MyType创建的对象",self) #Foo
super(MyType,self).__init__(*args,**kwargs)
def __call__(self, *args, **kwargs):
obj = super(MyType,self).__call__(*args,**kwargs)
print("类创建对象",self,obj) #Foo
class Foo(object,metaclass=MyType): # 对象加括号会去执行__call__方法，__call__方法里面继承了type的__call__方法
，type的__call__方法里面会先执行__new__方法，再去执行__init__方法。
所以，Foo就是用type创建出来的
user = "haiyan"
age = 18
obj = Foo()
# 方式二
class MyType(type):
def __init__(self, *args, **kwargs):
print("ssss")
super(MyType, self).__init__(*args, **kwargs)
def __call__(cls, *args, **kwargs):
v = dir(cls)
obj = super(MyType, cls).__call__(*args, **kwargs)
return obj
# 对象加括号就会去执行__call__方法
class Foo(MyType('Zcc', (object,), {})): # MyType('Zcc', (object,), {})相当于class Zcc(object):pass,也就是创建了一个Zcc的类
user = 'haiyan'
age = 18
obj = Foo()
# 方式三
class MyType(type):
def __init__(self, *args, **kwargs):
print("ssss")
super(MyType, self).__init__(*args, **kwargs)
def __call__(cls, *args, **kwargs):
v = dir(cls)
obj = super(MyType, cls).__call__(*args, **kwargs)
return obj
# 对象加括号就会去执行__call__方法
def with_metaclass(arg,base):
print("类对象",MyType('Zcc', (base,), {}))
return arg('Zcc', (base,), {}) # 返回一个类对象 class ASD(type):
pass
qqq = ASD("qwe", (object,), {}) #用ASD这个元类创建了一个（qwe,并且继承object类的）类
# class ASD(qwe):
# pass
obj = qqq()
# 能创建类的是元类
# 能创建对象的是类
print(obj) # <__main__.qwe object at 0x00000000024FFBA8>
print(obj.__class__) # 装饰器 实现的单例模式
def Singleton(cls):
_instance = {}
def _singleton(*args, **kargs):
if cls not in _instance:
_instance[cls] = cls(*args, **kargs)
return _instance[cls]
return _singleton
@Singleton
class A(object):
a = 1
def __init__(self, x=0):
self.x = x
a1 = A(2)
a2 = A(3)
------
def wrapper(cls):
instance = {}
def inner(*args,**kwargs):
if cls not in instance:
instance[cls] = cls(*args,**kwargs)
return instance[cls]
return inner
@wrapper
class Singleton(object):
def __init__(self,name,age):
self.name = name
self.age = age
obj1 = Singleton('jaychou',22)
obj2 = Singleton('eason',22)
print(obj1)
print(obj2)
单例模式的应用
单例模式的应用（在数据库连接池中用到单例模式）
import pymysql
import threading
from DBUtils.PooledDB import PooledDB
class SingletonDBPool(object):
_instance_lock = threading.Lock()
def __init__(self):
self.pool = PooledDB(
creator=pymysql, # 使用链接数据库的模块
maxconnections=6, # 连接池允许的最大连接数，0和None表示不限制连接数
mincached=2, # 初始化时，链接池中至少创建的空闲的链接，0表示不创建
maxcached=5, # 链接池中最多闲置的链接，0和None不限制
maxshared=3,
# 链接池中最多共享的链接数量，0和None表示全部共享。PS: 无用，因为pymysql和MySQLdb等模块的 threadsafety都为1，所有值无论设置为多少，_maxcached永远为0，所以永远是所有链接都共享。
blocking=True, # 连接池中如果没有可用连接后，是否阻塞等待。True，等待；False，不等待然后报错
maxusage=None, # 一个链接最多被重复使用的次数，None表示无限制
setsession=[], # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
ping=0,
# ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
host='127.0.0.1',
port=3306,
user='root',
password='123',
database='pooldb',
charset='utf8'
)
def __new__(cls, *args, **kwargs):
if not hasattr(SingletonDBPool, "_instance"):
with SingletonDBPool._instance_lock:
if not hasattr(SingletonDBPool, "_instance"):
SingletonDBPool._instance = object.__new__(cls, *args, **kwargs)
return SingletonDBPool._instance
def connect(self):
return self.pool.connection()