【编程思想】【设计模式】【创建模式creational】Borg/Monostate

Python版

https://github.com/faif/python-patterns/blob/master/creational/borg.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
*What is this pattern about?
The Borg pattern (also known as the Monostate pattern) is a way to
implement singleton behavior, but instead of having only one instance
of a class, there are multiple instances that share the same state. In
other words, the focus is on sharing state instead of sharing instance
identity.
>>Borg设计模式(我们通常叫它Monostate模式)是一个用来实现单例的行为，
>>但是它不是一个类只有一个实例，它有很多实例共享相同的状态。
>>换句话说，它专注在共享状态而不是共享实例

*What does this example do?
To understand the implementation of this pattern in Python, it is
important to know that, in Python, instance attributes are stored in a
attribute dictionary called __dict__.
>>为了弄明白这个设计模式在python中的实现，我们必须要知道，
>>在python中，实例的属性是存储在一个属性字典中，叫做__dict__
Usually, each instance will have
its own dictionary, but the Borg pattern modifies this so that all
instances have the same dictionary.
>>通常来说，每个实例都有它自己的字典，但是Borg模式修改了他
>>所以所有实例都有相同的字典
In this example, the __shared_state attribute will be the dictionary
shared between all instances, and this is ensured by assigining
__shared_state to the __dict__ variable when initializing a new
instance (i.e., in the __init__ method).
>>在这个例子中，属性__shared_state作为字典被所有实例共享，
>>这就确保了在初始化一个实例的时候(例如 __init__方法)，
Other attributes are usually
added to the instance's attribute dictionary, but, since the attribute
dictionary itself is shared (which is __shared_state), all other
attributes will also be shared.
>>其他的属性其他属性经常被添加到实例属性字典，但是，因为属性字典本身是被共享的
>>(__shared_state)，所以所有其他的属性也是被共享的
For this reason, when the attribute self.state is modified using
instance rm2, the value of self.state in instance rm1 also chages. The
same happends if self.state is modified using rm3, which is an
instance from a subclass.
>>因为这个原因，但是属性self.state被实例rm2修改之后，rm1中self.state的值也改变了
>>如果子类的实例rm3修改了self.state也会发生相同的事情
Notice that even though they share attributes, the instances are not
the same, as seen by their ids.
>>注意，即使他们共享属性，实例也是不一样的，从他们的id就能看出来

*Where is the pattern used practically?
Sharing state is useful in applications like managing database connections:
>>共享属性在管理数据库连接的应用中非常实用
https://github.com/onetwopunch/pythonDbTemplate/blob/master/database.py

*References:
https://fkromer.github.io/python-pattern-references/design/#singleton

*TL;DR80
Provides singletone-like behavior sharing state between instances.
"""


class Borg(object):
    __shared_state = {}

    def __init__(self):
        self.__dict__ = self.__shared_state
        self.state = 'Init'

    def __str__(self):
        return self.state


class YourBorg(Borg):
    pass


if __name__ == '__main__':
    rm1 = Borg()
    rm2 = Borg()

    rm1.state = 'Idle'
    rm2.state = 'Running'

    print('rm1: {0}'.format(rm1))
    print('rm2: {0}'.format(rm2))

    rm2.state = 'Zombie'

    print('rm1: {0}'.format(rm1))
    print('rm2: {0}'.format(rm2))

    print('rm1 id: {0}'.format(id(rm1)))
    print('rm2 id: {0}'.format(id(rm2)))

    rm3 = YourBorg()

    print('rm1: {0}'.format(rm1))
    print('rm2: {0}'.format(rm2))
    print('rm3: {0}'.format(rm3))

### OUTPUT ###
# rm1: Running
# rm2: Running
# rm1: Zombie
# rm2: Zombie
# rm1 id: 140732837899224
# rm2 id: 140732837899296
# rm1: Init
# rm2: Init
# rm3: Init