标签：数据 任务管理 场景 3.5 import 生成 threading __name__ 额外
一、单例模式理论单例模式：
保证某一个类只有一个实例，而且在全局只有一个访问点
优点：
1、由于单例模式要求在全局内只有一个实例，因而可以节省比较多的内存空间
2、全局只有一个接入点，可以更好地进行数据同步控制，避免多重占用
3、单例可长驻内存，减少系统开销
缺点：
1、单例模式的扩展是比较困难的
2、赋予了单例模式太多的职责，某种程度上违反了单一职责原则（六大设计原则之一）
3、单例模式是并发协作软件模块中需要最先完成的，因而其不利于测试
4、单例模式在某种情况下会导致资源瓶颈
应用场景：
1、生成全局唯一的变量，比如序列号
2、访问全局复用的唯一资源，如磁盘，总线等
3、单个对象占用的资源太多，如数据库等
4、系统全局统一管理，如windows下的任务管理器
二、对__new__的分析
# class Demo:
# def __init__(self, name):
# self.name = name
#
# def show_name(self):
# print("Name is: {}".format(self.name))
#
# if __name__ == '__main__':
#
# d = Demo("toby")
# d.show_name()
'''
引用大神的描述：
这样便是__init__最普通的用法了。但__init__其实不是实例化一个类的时候第一个被调用的方法。
当使用Demo("toby")这样的表达式来实例化一个类时，最先被调用的方法其实是 __new__ 方法。
__new__ 方法是什么？
__new__方法接受的参数虽然也是和__init__一样，但__init__是在类实例创建之后调用，而__new__方法正是创建这个类实例的方法。
'''
class Demo:
def __new__(cls, name):
print("Call __new__")
class_instance = super(Demo, cls).__new__(cls)
print("new创建了类实例：", class_instance) #打印一下
return class_instance #返回Demon类的一个实例给__init__，然后利用这个实例来调用类的__init__方法
def __init__(self, name): #那__init__用什么来接收__new__返回来的类实例呢？答案就是self
print("init接收到new返回回来的类实例：", self) #打印一下这个self，也就是看一下由__new__产生的实例
print("Call __init__")
self.name = name
def show_name(self):
print("Name is: {}".format(self.name))
#
# if __name__ == '__main__':
# d = Demo("toby")
# d.show_name()
'''
引用大神的总结：
所以，__init__ 和 __new__ 最主要的区别在于：
1、__init__ 通常用于初始化一个新实例，控制这个初始化的过程，比如添加一些属性，
做一些额外的操作，发生在类实例被创建完以后。它是实例级别的方法。
2、__new__ 通常用于控制生成一个新实例的过程。它是类级别的方法。
但是说了这么多，__new__最通常的用法是什么呢，我们什么时候需要__new__？，单例模式就是一个很好的例子
'''三、单例模式（案例1）
#coding:utf-8
import threading
import time
#这里使用方法__new__来实现单例模式
class Singleton(object): #抽象单例
def __new__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"):
orig = super(Singleton, cls)
cls._instance = orig.__new__(cls, *args, **kwargs)
return cls._instance
#总线
class Bus(Singleton):
lock = threading.RLock()
def sendData(self, data):
self.lock.acquire()
time.sleep(3)
print("Sending Signal Data...", data)
self.lock.release()
#线程对象，为更加说明单例的含义，这里讲Bus对象实例化在了run里
class VisitEntity(threading.Thread):
my_bus = ""
name = ""
def getName(self):
return self.name
def setName(self, name):
self.name = name
def run(self):
self.my_bus = Bus()
self.my_bus.sendData(self.name)
if __name__ == '__main__':
for i in range(3):
print("Entity {} begin to run...".format(i))
v = VisitEntity()
v.setName("Toby"+str(i))
v.start()四、单例模式（案例2）
#使用__new__类方法来保证只有一个实例被创建出来
class OneOnly(object):
_singleton = None
def __new__(cls, *args, **kwargs):
if not cls._singleton: #判断是否创建有实例，如果没有则调用super()函数来创建它
cls._singleton = super(OneOnly, cls).__new__(cls) #构造方法__new__被调用时，会构造该类的一个新实例
return cls._singleton
#定义一个普通的类，仅有初始化方法__init__
class Test:
def __init__(self, name):
self.name = name
#定义一个Demo类，并继承实现单例模式的OneOnly类
class Demo(OneOnly):
def __init__(self, name):
self.name = name
def chage_name(self, new_name):
self.name = new_name
def show_name(self):
print("Name is: {}".format(self.name))
if __name__ == '__main__':
#当通过OneOnly类中的构造方法构造实例时，总是会的得到完全相同的实例，内存地址也相同
# o1 = OneOnly()
# o2 = OneOnly()
# print(o1)
# print(o2)
#通过Test类创建出来的两个实例t1和t2，是两个不同的实例，内存地址也是不同的
# t1 = Test("toby")
# t2 = Test("ttr")
# print(t1)
# print(t2)
#Demo类继承了实现了单例模式的OneOnly类，因此，通过Demo类实例化出来的对象都是同一个对象
d1 = Demo("toby")
d2 = Demo("ttr")
d3 = Demo("laowang")
# 通过打印可知，他们的内存地址都是一样的
# print(d1)
# print(d2)
#发现打印出来的name都是"laowang"，似乎最后创建的一个实例把前两个的给覆盖了
d1.show_name()
d2.show_name()
d3.show_name()
#通过实例d1修改名字后，再通过实例d3和d2来查看，果然也一起改变了。由此证明他们确实是同一个实例
d1.chage_name("juck")
d3.show_name()
d2.show_name()标签：数据 任务管理 场景 3.5 import 生成 threading __name__ 额外
原文地址：http://blog.51cto.com/freshair/2069887
