Python中的单例

最新推荐文章于 2023-07-26 15:46:48 发布
最新推荐文章于 2023-07-26 15:46:48 发布
阅读量527 收藏 5
点赞数 1
分类专栏： Python 文章标签： 单例 Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lixinghua666/article/details/93201838
版权

Python中的单例

单例模式（Singleton pattern），是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。

Python 中实现单例的几种方法：

  • 使用模块
  • 使用函数装饰器
  • 使用类装饰器
  • 使用类
  • 基于__new__方法实现
  • 基于元类（metaclass）方式实现

一、使用模块

其实，Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。

# mysingle.py
class MySingle:
　　def foo(self):
　　　　pass

sinleton = MySingle()

将上面的代码保存在文件 mysingle.py 中，然后这样使用：

from mysingle import sinleton
singleton.foo()

二、使用函数装饰器

def singleton(cls):
    _instance = {}

    def inner():
        if cls not in _instance:
            _instance[cls] = cls()
        return _instance[cls]
    return inner
    
@singleton
class Cls(object):
    def __init__(self):
        pass

cls1 = Cls()
cls2 = Cls()
print(id(cls1) == id(cls2))

输出结果：true

在 Python 中，id 关键字可用来查看对象在内存中的存放位置，这里 cls1 和 cls2 的 id 值相同，说明他们指向了同一个对象。代码中比较巧妙的一点是：

_instance = {}

使用不可变的类地址作为键，其实例作为值，每次创造实例时，首先查看该类是否存在实例，存在的话直接返回该实例即可，否则新建一个实例并存放在字典中。

三、使用类装饰器

class Singleton(object):

    def __init__(self, cls):
        self._cls = cls
        self._instance = {}

    def __call__(self):
        if self._cls not in self._instance:
            self._instance[self._cls] = self._cls()
        return self._instance[self._cls]

@Singleton
class Cls2(object):
    def __init__(self):
        pass

cls1 = Cls2()
cls2 = Cls2()
print(id(cls1) == id(cls2))

同时，由于是面向对象的，这里还可以这么用：

class Cls3():
    pass

Cls3 = Singleton(Cls3)
cls3 = Cls3()
cls4 = Cls3()
print(id(cls3) == id(cls4))

使用类装饰器实现单例的原理和函数装饰器实现的原理相似。

四、使用类

class Singleton(object):

    def __init__(self):
        pass

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

一般情况，大家以为这样就完成了单例模式，但是这样当使用多线程时会存在问题

class Singleton(object):

    def __init__(self):
        pass

    @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 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>

看起来也没有问题，那是因为执行速度过快，如果在 init 方法中有一些 IO 操作，就会发现问题了，下面我们通过 time.sleep 模拟

我们在上面 __init__ 方法中加入以下代码：

    def __init__(self):
        import time
        time.sleep(1)

重新执行程序后，结果如下：

<__main__.Singleton object at 0x034A3410>
<__main__.Singleton object at 0x034BB990>
<__main__.Singleton object at 0x034BB910>
<__main__.Singleton object at 0x034ADED0>
<__main__.Singleton object at 0x034E6BD0>
<__main__.Singleton object at 0x034E6C10>
<__main__.Singleton object at 0x034E6B90>
<__main__.Singleton object at 0x034BBA30>
<__main__.Singleton object at 0x034F6B90>
<__main__.Singleton object at 0x034E6A90>

问题出现了！按照以上方式创建的单例，无法支持多线程

解决办法：加锁！未加锁部分并发执行,加锁部分串行执行,速度降低,但是保证了数据安全

import time
import threading
class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
        time.sleep(1)

    @classmethod
    def instance(cls, *args, **kwargs):
        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)

打印结果如下：

<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>

这样就差不多了，但是还是有一点小问题，就是当程序执行时，执行了 time.sleep(20) 后，下面实例化对象时，此时已经是单例模式了，但我们还是加了锁，这样不太好，再进行一些优化，把 intance 方法，改成下面的这样就行：

    @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

这样，一个可以支持多线程的单例模式就完成了

完整代码为：

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()

如果用 obj=Singleton() ,这种方式得到的不是单例

五、基于__new__方法实现

通过上面例子，我们可以知道，当我们实现单例时，为了保证线程安全需要在内部加入锁

我们知道，当我们实例化一个对象时，是先执行了类的__new__方法（我们没写时，默认调用object.__new__），实例化对象；然后再执行类的__init__方法，对这个对象进行初始化，所以我们可以基于此，实现单例模式

基本原理：

class Single(object):
    _instance = None
    def __new__(cls, *args, **kw):
        # 关键在这里，每一次实例化的时候，我们都只会返回这同一个instance对象
        if cls._instance is None:
            cls._instance = object.__new__(cls, *args, **kw)
        return cls._instance
    def __init__(self):
        pass

single1 = Single()
single2 = Single()
print(id(single1) == id(single2))

完整代码：

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"):
                    Singleton._instance = object.__new__(cls)  
        return Singleton._instance

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()

六、基于元类（metaclass）方式实现

在实现单例之前，需要了解使用 type 创造类的方法，例子如下：

def func(self):
    print("do something")

Klass = type("Klass", (), {"func": func})

c = Klass()
c.func()

  1. 类由type创建，创建类时，type的__init__方法自动执行，类() 执行type的 __call__方法(类的__new__方法,类的__init__方法)

  2. 对象由类创建，创建对象时，类的__init__方法自动执行，对象() 执行类的 __call__ 方法

    例子如下：

    class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        pass

obj = Foo()
# 执行type的 __call__ 方法，调用 Foo类（是type的对象）的 __new__方法，用于创建对象，然后调用 Foo类（是type的对象）的 __init__方法，用于对对象初始化。

obj()    # 执行Foo的 __call__ 方法

以上，我们使用 type 创造了一个类出来。这里的知识是 mataclass 实现单例的基础。

class SingletonType(type):
    def __init__(self, *args, **kwargs):
        super(SingletonType, self).__init__(*args, **kwargs)

    def __call__(cls, *args, **kwargs): # 这里的cls，即Foo类
        print('cls', cls)
        obj = cls.__new__(cls, *args, **kwargs)
        cls.__init__(obj, *args, **kwargs) # Foo.__init__(obj)
        return obj

class Foo(metaclass=SingletonType): # 指定创建Foo的type为SingletonType
    def __init__(self，name):
        self.name = name
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls)

obj = Foo('xx')

这里，我们将 metaclass 指向 Singleton 类，让 Singleton 中的 type 来创造新的 Foo 实例。

本文虽然是讲单例模式，但在实现单例模式的过程中，涉及到了较多 Python 高级语法，包括装饰器、元类、new、type 甚至 super 等等。刚开始可能难以理解，其实在工程项目中并不需要你掌握的面面俱到，掌握其中一种，剩下的作为了解即可。

lixinghua666
关注
专栏目录
Python中实现单例模式的最佳实践
windowshht的博客
04-24 1700
在软件开发中，单例模式是一种常见的设计模式，它确保一个类仅有一个实例，并提供一个全局访问点来获取该实例。这种模式在多个场景中都很有用，比如配置管理、日志记录、线程池等。Python作为一种灵活且强大的编程语言，提供了多种实现单例模式的方法。本文将介绍几种在Python中实现单例模式的常用方法，并提供相应的代码示例。一、使用模块导入实现单例模式在Python中，模块是天然的单例。当模块被第一次导入时，会创建模块对象，并且在后续导入中，Python会重用该对象。因此，我们可以利用这一特性来实现单例模式。
Python中的单例模式的几种实现方式的及优化
aobian2884的博客
01-08 1704
单例模式 单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。 比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方...
Python 中的单例模式
weixin_34252686的博客
01-17 179
单例模式 单例模式（SingletonPattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。 比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 Ap...
python中的单例
weixin_31449201的博客
04-27 310
class Practice(object): cls_flag = False def __new__(cls): if cls.cls_flag == False: cls.cls_flag = object.__new__(cls) # 注意object.__new__(cls)括号中的cls，将类传到父类object中 ...
Python----单例
Damys
01-12 976
目的：让类创建对象，在系统中只有唯一的一个实例。 每一次执行类名()返回的对象，内存地址是相同的 需要重写new内置方法，一定要返回return supper().new(cls) new 为对象分配空间，返回对象的引用 init对象初始化，定义实例属性 class MusicPlayer(object): def __new__(cls, *args, **kwargs):
Python之单例
ysysys333的博客
10-30 224
单例 让类创建的对象，在系统中只有唯一的一个实例 定义类属性，初始值为空，记录单例对象的引用 重写__new__方法 如果类属性 is None ，调用父类方法分配空间，在类属性中记录结果 返回类属性中记录的对象引用 class MusicPlay(object): istance = None def __new__(cls, *args, **kwargs): if cl...
Python 实现单例模式的五种写法
SixStar_FL的博客
09-16 9293
单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
Python实现单例模式的几种方式
weixin_50097774的博客
11-18 3396
认识单例模式 含义 单例模式是一种常用的软件设计模式，在应用这个模式时,类只会生成一个实例对象。 换句话说，单例模式确保某个类有且仅有一个实例，而且自行实例化并向整个系统提供这个实例，当我们在程序中的不同位置调用这个类进行实例化，如果类的实例不存在，会创建一个实例；如果已存在就会返回这个实例。 比如回收站就是单例模式的应用，我们电脑桌面上都有一个回收站，在整个操作系统中，回收站只能有一个实例，整个系统都是使用这个唯一的实例。 优点 因为单例模式在全局内只有一个实例，因此可以节省比较多的内存空间。
关于python中的单例
gymaisyl的博客
10-24 144
下面将通过一段代码解释一下，如何实现单例： class OnlyOne(object): # 记录第一个被创建对象的引用 instance = None # 记录是否执行过初始化动作 init_flag = False def __new__(cls, *args, **kwargs): # 1. 判断类属性是否是空对象 ...
python-单例模式
ljsykf的博客
03-24 1696
单例设计模式 让类创建的对象，在系统中只有唯一的一个实例 每一次执行类名()，返回的对象，内存地址是相同的 __new__方法 使用类名()创建对象时，python的解释器首先会调用__new__方法为对象分配空间 __new__是一个由object基类提供的内置的静态方法，主要作用有两个： 1. 在内存中为对象分配空间 2. 返回对象的引用 python的解释器获得对象的引用后，将引用作为第一个参数，传递给__init__方法 重写__new__方法一定要return super().new(cls) 否
单例-初始化动作只执行一次
Leon_Jinhai_Sun的博客
10-08 361
class MusicPlayer(object): # 记录第一个被创建对象的引用 instance = None # 记录是否执行过初始化动作 init_flag = False def __new__(cls, *args, **kwargs): # 1. 判断类属性是否是空对象 if cls.instance...
Python实现单例模式
最新发布
bb8886的博客
07-26 9258
Python中单例模式的实现方法和应用场景
Python 实现单例
有关心情
06-11 8147
Python 实现单例 文章目录Python 实现单例起步__new__函数元类 metaclass装饰器函数装饰器类装饰器方法静态方法 staticmethod类方法 classsmethod名字覆盖属性共享 起步 单例模式是一种常用的软件设计模式，用来确保一个类只会有一个实例存在。 以下是 Python 中实现单例模式的多种方法，环境基于 Python3.6.6。 __new__函数 cl...
python单例
weixin_42345642的博客
09-18 136
class ExpressQuery: # 定义类属性记录单例对象引用 _instance = None # 创建单例 def __new__(cls): # 1. 判断类属性是否已经被赋值 if cls._instance is None: cls._instance = super(ExpressQuer...
python 单例
易水寒
05-26 1780
在python中，我们可以用多种方法来实现单例模式：- 使用模块- 使用__new__- 使用装饰器- 使用元类（metaclass）1.使用模块 # mysingle.py class MySingle: 　　def foo(self): 　　　　pass sinleton = MySingle() 将上面的代码保存在文件mysingle.py中，然后这样使用： from mysingle ...
Python单例
weixin_45833534的博客
01-02 134
单例模式就是确保一个类只有一个实例 实现单例模式的几种方式 1，使用模块 2，使用装饰器 3，使用类 4，基于__new__方法实现的单例（推荐使用） 一个对象的实例化过程是先执行类的__new__方法，如果我们没有没有写，默认会调用object的__new__方法，返回一个实例化对象，然后再调用__init__方法，对这个对象进行初始化，我们可以根据这个实现单例 在一个类的__new__方法中 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值