python单例模式及使用场景（跨文件全局变量）

Python单例模式

概述

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

从具体实现角度来说，就是以下三点：一是单例模式的类只提供私有的构造函数，二是类定义中含有一个该类的静态私有对象，三是该类提供了一个静态的共有函数用于创建或获取它本身的静态私有对象。

应用

一些资源管理器常常设计成单例模式

在计算机系统中，需要管理的资源包括软件外部资源，譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印机作业同时输出到打印机中。每台计算机可以有若干传真机卡，但是只应该有一个软件负责管理传真卡，以避免一个通信端口同时被两个请求同时调用。

需要管理的资源包括软件内部资源，譬如，大多数的软件都有一个（甚至多个）属性（properties）文件存放系统配置。这样的系统应当由一个对象来管理一个属性文件。

需要管理的软件内部资源也包括负责记录网站来访人数的部件，记录软件系统内部事件、出错信息的部件，或是对系统的表现进行检查的部件等。其一，这些资源管理器构件必须只有一个实例；其二，它们必须自行初始化；其三，允许整个系统访问自己。因此，它们都满足单例模式的条件，是单例模式的应用。

优缺点

优点：

1、实例控制

单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

2、灵活性

因为类控制了实例化过程，所以类可以灵活更改实例化过程。

缺点：

1、开销

虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

2、可能的开发混淆

使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

3、对象生成期

不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致单例类中出现悬浮引用。

实现方式

1. 实现__new__方法，然后将类的一个实例绑定到类变量_instance上；如果cls._instance为None，则说明该类还没有被实例化过，new一个该类的实例，并返回；如果cls._instance不为None，直接返回_instance，代码如下：

   class Singleton(object):
       def __new__(cls, *args, **kwargs):
           if not hasattr(cls,'_instance'):
               orig=super(Singleton,cls)
               cls._instance=orig.__new__(cls)
           return cls._instance
   
   class MyClass(Singleton):
       a=1
   
   one=MyClass()
   two=MyClass()
   
   # one和two完全相同，可以用id()，==，is检查
   print(one.a)    # 1
   print(id(one))  # 2565285375728
   print(id(two))  # 2565285375728
   print(one == two)   # True
   print(one is two)   # True
   

2. 本质上是方法一的升级版，使用metaclass（元类）的python高级用法，具体代码如下

   """
   class Singleton中的__init__在Myclass声明的时候被执行Myclass=Singleton()
   Myclass()执行时，最先执行父类的__call__方法（object,Singleton都作为Myclass的父类，
   根据深度优先算法，会执行Singleton中的__call__()，Singleton中的__call__()写了单例模式）
   """
   class Singleton(type):
   
       def __init__(self, name, bases, dict):
           super(Singleton,self).__init__(name,bases, dict)
           self._instance = None
   
       def __call__(self, *args, **kwargs):
           if self._instance is None:
               self._instance = super(Singleton,self).__call__(*args, **kwargs)
           return self._instance
   
   class MyClass(object,metaclass=Singleton):
       a = 1
   
   one=MyClass()
   two=MyClass()
   print(id(one))  # 1553247294800
   print(id(two))  # 1553247294800
   print(one == two)   # True
   print(one is two)   # True
   

3. 使用python的装饰器（decorator）实现单例模式，这是一种更Pythonic的方法；单例类本身的代码不是单例的，通过装饰器使其单例化，代码如下：

   def singleton(cls, *args, **kwargs):
       instances = {}
       
       def _singleton():
           if cls not in instances:
               instances[cls] = cls(*args, **kwargs)
           return instances[cls]
       return _singleton
   
   @singleton
   class MyClass3(object):
       a = 1
   
   one = MyClass3()
   two = MyClass3()
   
   print(id(one))  # 2880466769232
   print(id(two))  # 2880466769232
   print(one == two)   # True
   print(one is two)   # True
   

常用

python的单例模式__new__()在__init__()之前被调用，用于生产实例对象。利用这个方法和类的属性的特点可以实现设计模式的单例模式。单例模式是指创建唯一对象，单例模式设计的类只能实例化一个对象。

class Singleton(object):
    __instance=None

    def __init__(self):
        pass
    def __new__(cls, *args, **kwargs):
        if Singleton.__instance is None:
            Singleton.__instance=object.__new__(cls,*args, **kwargs)
        return Singleton.__instance

one=Singleton()
two=Singleton()
print(id(one))  # 2488569943376
print(id(two))  # 2488569943376
print(one == two)   # True
print(one is two)   # True

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单列类的特殊类。通过单列模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而便于对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最后的解决方案。

总结

内容：保证一个类只有一个实例，并提供一个访问它的全局访问点。
适用场景：当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时
优点：
对唯一实例的受控访问
单例相当于全局变量，但防止了命名空间被污染
与单例模式功能相似的概念：全局变量、静态变量（方法）

用例

之前有过跨文件全局变量的使用场景，当时是通过单独建立一个文件去保存全局变量来实现的

global_var.py

# -*- coding: utf-8 -*-

def _init():  # 初始化
   global _global_dict
   _global_dict = {}

def set_value(key, value):
   """ 定义一个全局变量 """
   _global_dict[key] = value

def get_value(key, defValue=None):
   """
   获得一个全局变量,不存在则返回默认值
   """
   return _global_dict.get(key, defValue)

master.py

import time
import global_var as glo
import slave.py

glo._init()
glo.set_value('start', True)

if __name__ == '__main__':
 while 1:
    if glo.get_value('start'):
        print('TTTTTT')
    else:
        print('FFFFFF')
    time.sleep(1)

slave.py

import threading
import time

import global_var as glo

def fun():
 while 1:
     glo.set_value('start', False)
     print(glo.get_value('start'))
     time.sleep(2)
     glo.set_value('start', True)
     print(glo.get_value('start'))
     time.sleep(2)

t = threading.Thread(target=fun) # 必要
t.start()

直接执行python master.py

下面使用单例模式实现

singleton.py

class Singleton:
    def __init__(self):
        self.start = False

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

master.py

import time
from singleton import Singleton
import slave

if __name__ == '__main__':
    single = Singleton()
    while 1:
        if single.start:
            print('TTTTTT')
        else:
            print('FFFFFF')
        time.sleep(1)

slave.py

import time
from singleton import Singleton
import threading


def fun():
    single = Singleton()
    while 1:
        single.start = True
        print(single.start)
        time.sleep(2)
        single.start = False
        print(single.start)
        time.sleep(2)


t = threading.Thread(target=fun)
t.start()

参考python中的单例模式 - 申不二 - 博客园 (cnblogs.com)