单列模式，装饰器、new方法、类/静态方法实现单列模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。

如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 Config 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 Config 对象的实例，这就导致系统中存在多个 Config 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 Config 这样的类，我们希望在程序运行期间只存在一个实例对象。

通过python的闭包原理，装饰器能记得外层命名空间装饰器原理参考本文

def single_decorator(cls):

    single = {}

    def wrapper(*args, **kwargs):

        if not single.get(cls.__name__):

            single[cls.__name__] = cls(*args, **kwargs)

        return single[cls.__name__]

    return wrapper

@single_decorator

class School:

    def __init__(self, name, addr, capital, represent):

        self.__name = name      #学校名

        self.__addr = addr      #地址

        self.__registered_capital = capital     #注册资金

        self.__represent = represent        #法人代表

    def get_info(self):

        return "校名: {} 地址: {} 法人代表: {}".format(self.__name, self.__addr, self.__represent)

    @staticmethod

    def show():

        print(School._isxx)

ss= School('古天乐学校', '大凉山', '100.000', '古天乐')

ss2= School('施明德', '台湾？', '1.000.000', '瞎写的')

print('实例一id: %s'%(id(ss)))

print('实例二id: %s'%(id(ss2)))

print(ss.get_info())

print(ss2.get_info())

#运行结果为：

实例一id: 397109139440

实例二id: 397109139440

校名: 古天乐学校 地址: 大凉山 法人代表: 古天乐

校名: 古天乐学校 地址: 大凉山 法人代表: 古天乐

这样就可以将这个装饰器装饰到任何一个类上，完成单列了

class Single:

    _single = None

    def __init__(self, value):

        self.v = value

        print(self.v)

    def __new__(cls, *args, **kwargs):

        if Single._single:

            return Single._single

        else:

            Single._single = super(Single, cls).__new__(cls)

            print("只执行一次")

            return Single._single

s2 = Single(2)

s3 = Single(3)

s4 = Single(4)

print(id(s2))

print(id(s3))

print(id(s4))

#输出结果为

只执行一次

2

3

4

s2的id为: 278042421064

s3的id为: 278042421064

s4的id为: 278042421064

• 和类方法相类似，可以看见，s2/s3/s4 都是同一个id 是同一个实例，尽管实例时传入的值不一样

平时我们在链接数据库时，一个程序，也是只需要一个链接就够了，我们不希望一个程序产生很多实例去连接到数据库，这样每个链接都操作数据库，不但浪费了内存空间，还可能导致数据修改混乱

class Sqlpool:

    __single = None #创建一个静态字段

    def __init__(self):

        #封装数据库链接需要的信息

        self.ip = "192.168.1.1"

        self.port = 3306

        self.pwd = "1234567"

        self.username = "xxxxxx"

        #链接数据库

        self.connect = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] #假如创建了9个链接数据库的线

    @staticmethod

    def produce():

        if Sqlpool.__single: #判断静态字段是否有值

            return Sqlpool.__single #如果有值返回静态字段的值

        else:

            Sqlpool.__single = Sqlpool() #没有就实例一个对象给他

            return Sqlpool.__single     #将实例返回

#这样，无论创建多少个访问，对象时，都是一个对象，这样不会占用内存

conn1 = Sqlpool.produce() #创建一个访问对象

conn2 = Sqlpool.produce() #创建二个访问对象

原理都差不多。这个没有装饰器好用

class Singleton(object):

    def __init__(self):

        pass

    @classmethod

    def get(cls, *args, **kwargs):

        if not hasattr(Singleton, "_single"):

            Singleton._single = Singleton(*args, **kwargs)

        return Singleton._single

类方法这儿实现单列模式还有优化，就不多说了，是多线程问题。

这儿本身原理和静态方法差不多。