为什么Borg pattern优于Singleton pattern?
我问,因为我没有看到它们导致任何不同。
博格:
class Borg:
__shared_state = {}
# init internal state variables here
__register = {}
def __init__(self):
self.__dict__ = self.__shared_state
if not self.__register:
self._init_default_register()
的Singleton:
class Singleton:
def __init__(self):
# init internal state variables here
self.__register = {}
self._init_default_register()
# singleton mechanics external to class, for example this in the module
Singleton = Singleton()
我想在这里显示的是服务对象,无论是作为Borg还是Singleton实现,都有一个非常重要的内部状态(它提供了一些基于它的服务)(我的意思是它必须是有用的东西,它不是Singleton /博格只是为了好玩)。
这个状态必须得到启发。这里的Singleton实现更直接,因为我们将 init 视为全局状态的设置。我发现Borg对象必须查询其内部状态以查看它是否应该自行更新,这很尴尬。
你拥有的内部状态越差。例如,如果对象必须侦听应用程序的拆除信号以将其寄存器保存到磁盘,那么该注册也应该只执行一次,使用Singleton会更容易。
答案 0 :(得分:55)
borg不同的真正原因归结为子类化。
如果您继承了borg,则子类'对象具有与其父类对象相同的状态,除非您显式覆盖该子类中的共享状态。单例模式的每个子类都有自己的状态,因此会生成不同的对象。
同样在单例模式中,对象实际上是相同的,而不仅仅是状态(即使状态是唯一真正重要的东西)。
答案 1 :(得分:19)
在python中,如果你想要一个可以从任何地方访问的唯一“对象”,只需创建一个只包含静态属性Unique
和@staticmethod
s的类@classmethod
;你可以称之为独特模式。在这里,我实现并比较了3种模式:
唯一
#Unique Pattern
class Unique:
#Define some static variables here
x = 1
@classmethod
def init(cls):
#Define any computation performed when assigning to a "new" object
return cls
的Singleton
#Singleton Pattern
class Singleton:
__single = None
def __init__(self):
if not Singleton.__single:
#Your definitions here
self.x = 1
else:
raise RuntimeError('A Singleton already exists')
@classmethod
def getInstance(cls):
if not cls.__single:
cls.__single = Singleton()
return cls.__single
博格
#Borg Pattern
class Borg:
__monostate = None
def __init__(self):
if not Borg.__monostate:
Borg.__monostate = self.__dict__
#Your definitions here
self.x = 1
else:
self.__dict__ = Borg.__monostate
测试
#SINGLETON
print "\nSINGLETON\n"
A = Singleton.getInstance()
B = Singleton.getInstance()
print "At first B.x = {} and A.x = {}".format(B.x,A.x)
A.x = 2
print "After A.x = 2"
print "Now both B.x = {} and A.x = {}\n".format(B.x,A.x)
print "Are A and B the same object? Answer: {}".format(id(A)==id(B))
#BORG
print "\nBORG\n"
A = Borg()
B = Borg()
print "At first B.x = {} and A.x = {}".format(B.x,A.x)
A.x = 2
print "After A.x = 2"
print "Now both B.x = {} and A.x = {}\n".format(B.x,A.x)
print "Are A and B the same object? Answer: {}".format(id(A)==id(B))
#UNIQUE
print "\nUNIQUE\n"
A = Unique.init()
B = Unique.init()
print "At first B.x = {} and A.x = {}".format(B.x,A.x)
A.x = 2
print "After A.x = 2"
print "Now both B.x = {} and A.x = {}\n".format(B.x,A.x)
print "Are A and B the same object? Answer: {}".format(id(A)==id(B))
输出:
SINGLETON
At first B.x = 1 and A.x = 1 After A.x = 2 Now both B.x = 2 and A.x = 2 Are A and B the same object? Answer: True BORG At first B.x = 1 and A.x = 1 After A.x = 2 Now both B.x = 2 and A.x = 2 Are A and B the same object? Answer: False UNIQUE At first B.x = 1 and A.x = 1 After A.x = 2 Now both B.x = 2 and A.x = 2 Are A and B the same object? Answer: True
在我看来,唯一的实现是最简单的,然后是Borg,最后是Singleton,其定义需要两个函数的丑陋数量。
答案 2 :(得分:13)
不是。通常不推荐的是python中的这种模式:
class Singleton(object):
_instance = None
def __init__(self, ...):
...
@classmethod
def instance(cls):
if cls._instance is None:
cls._instance = cls(...)
return cls._instance
您使用类方法来获取实例而不是构造函数。 Python的元编程允许更好的方法,例如Wikipedia上的那个:
class Singleton(type):
def __init__(cls, name, bases, dict):
super(Singleton, cls).__init__(name, bases, dict)
cls.instance = None
def __call__(cls, *args, **kw):
if cls.instance is None:
cls.instance = super(Singleton, cls).__call__(*args, **kw)
return cls.instance
class MyClass(object):
__metaclass__ = Singleton
print MyClass()
print MyClass()
答案 3 :(得分:8)
一个类基本上描述了如何访问(读/写)对象的内部状态。
在单例模式中,您只能拥有一个类,即所有对象都将为您提供与共享状态相同的访问点。 这意味着如果你必须提供一个扩展的API,你需要编写一个包装器,围绕单例进行包装
在borg模式中,您可以扩展基本的“borg”类,从而更方便地根据您的喜好扩展API。
答案 4 :(得分:8)
只有在你真正有所不同的少数情况下才会更好。就像你的子类。 Borg模式非常不寻常,我在Python编程的十年中从未需要它。
答案 5 :(得分:0)
此外,类似Borg的模式允许类的用户选择是否要共享状态或创建单独的实例。 (这可能是一个好主意是一个单独的主题)
class MayBeBorg:
__monostate = None
def __init__(self, shared_state=True, ..):
if shared_state:
if not MayBeBorg.__monostate:
MayBeBorg.__monostate = self.__dict__
else:
self.__dict__ = MayBeBorg.__monostate
return
self.wings = ..
self.beak = ..