单例模式

目的: 单个进程中只存在一个类的实例，从而可以实现数据的共享，节省系统开销，防止io阻塞等等

如何解决:判断系统是否已有这个单例,如果有则返回,如果没有就创建

但是在多进程的应用中，单例模式就实现不了了，例如一些web应用，django，这些，因为会启动多条进程来监听http请求，这样的会通过单例模式是实现不了数据共享的，也就是实现不了单例模式的目的了，这时需要用进程间通信方法来实现数据共享，当然也可以尝试使用redis这些数据库实现数据共享，因为它们的读取数据较快。

普通模式
class A(object):
    def __init__(self,name,male):
        self.name = name
        self.name = male

#实例化多个对象
obj1 = A('ben','boy')
obj2 = A('min','girl')
obj3 = A('miao','boy')
##打印内存地址，可以看到内存地址都是不一样的
print id(obj1),id(obj2),id(obj3)

单例模式有三种方法:

第一种方法:装饰器方法

def singleton(cls):
    instances = {}
    def wrapper(*args, **kwargs):
        if cls not in instances: # 如果类没有在 字典中
            instances[cls] = cls(*args, **kwargs)   # { 类名: 实例对象 }
        return instances[cls]
    return wrapper


@singleton
class Foo(object):
    def __init__(self,name):
        self.name = name


foo1 = Foo('a')
foo2 = Foo('b')
print id(foo1) 2794874519960
print id(foo2) 2794874519960

第二种方法 使用基类 注意此种方法不接受参数

class DiJi:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'_instance'):
            cls._instance = super(DiJi, cls).__new__(cls, *args, **kwargs)
        return cls._instance

class Foo(DiJi): 
    pass

foo1 = Foo()
foo2 = Foo()
print id(foo1)
print id(foo2)

第三种方法: 使用元类

元类: 用于创建类的类,类对象创建实例对象时一定会调用 __call__方法,因此在调用 __call__时候保证始终创建一个实例即可,type是python中的一个元类

class Singleton(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super().__call__(*args, **kwargs)
        return cls._instance


class Foo(metaclass = Singleton):  不可修改

    def __init__(self,name):
        self.name = name

foo1 = Foo('s')
foo2 = Foo('a')

print(id(foo1))
print(id(foo2))
print (foo1 is foo2)
结果
  3128008950336
  3128008950336
  True

第四种方法: 使用模块

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

ce.py 在这个文件中

class Singleton(object):
    def __init__(self,name):
        self.name = name

在另一个文件中

import ce2
print(id(ce2.Singleton('a')))
print(id(ce2.Singleton('b')))
print(id(ce2.Singleton('a')) == id(ce2.Singleton('b')))
结果
  1912694489664
  1912694489664
  True

多线程中的单例模式

进程: 系统进行资源分配和调度的最小单位
线程: CPU调度和分派的最小单位
协程: 用户控制的轻量级线程

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

import time
import os
import threading
class Singleton(object):
    _instance_lock = threading.Lock()    线程锁

    def __init__(self,xxx):
        self.xxx = xxx
        time.sleep(1)

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):  返回对象是否具有具有给定名称的属性。这是通过调用getattr（obj，name）
            with Singleton._instance_lock:    校验是否有线程锁
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance


def task(arg):
    print(arg)
    obj = Singleton.instance(arg)
    print('子线程>>',obj)
    # print('父进程PID',os.getppid())
    # print('当前进程PID:', os.getpid())

for i in range(10):
    t = threading.Thread(target=task,args=[i,]).start() # 开启子线程

time.sleep(5)
obj = Singleton.instance()   '类调用类方法 和 对象调用实例方法相同 cls和self不用传参,因为cls和self就代指的是类和对象,如果instance不是类方法,那就必须传递一个位置参数 cls'
print('主进程',obj)

结果
  数字就不列举了
  子线程>> <__main__.Singleton object at 0x000001737DDCB518>
  子线程>> <__main__.Singleton object at 0x000001737DDCB518>
  子线程>> <__main__.Singleton object at 0x000001737DDCB518>
  子线程>> <__main__.Singleton object at 0x000001737DDCB518>
  子线程>> <__main__.Singleton object at 0x000001737DDCB518>
  子线程>> <__main__.Singleton object at 0x000001737DDCB518>
  子线程>> <__main__.Singleton object at 0x000001737DDCB518>
  子线程>> <__main__.Singleton object at 0x000001737DDCB518>
  子线程>> <__main__.Singleton object at 0x000001737DDCB518>
  子线程>> <__main__.Singleton object at 0x000001737DDCB518>
  主进程 <__main__.Singleton object at 0x000001737DDCB518>