基于创建对象时传递的不同参数的单例/博格模式

Question

我正在使用borg模式在对象之间共享状态：

class Borg:
    __shared_state = {}
    def __init__(self):
        self.__dict__ = self.__shared_state

现在让我们假设我想根据我在创建对象时传递的参数创建 Borg 类的基于上下文的对象。这是为多个上下文创建Borg模式（状态共享）的正确方法吗？

import random
import cPickle
class Borg:
    __shared_state = { }
    def __init__(self,*args,**kwargs):
        context_key = hash('{0}{1}'.format(cPickle.dumps(args),cPickle.dumps(kwargs)))
        self.__shared_state.setdefault(context_key, {})
        self.__dict__ = self.__shared_state[context_key]
        print(self.__shared_state)
    def set_random_property(self):
        self.num =  str(random.randint(1,100000))

a = Borg(x='ONE')
a.set_random_property()
b = Borg(x = 'TWO')
b.set_random_property()
c = Borg(x = 'TWO')
print('a with ONE has num:{0}'.format(a.num))
print('b with TWO has num:{0}'.format(b.num))
print('c with TWO has num:{0}'.format(c.num))

输出

{7373348246660160089: {}}
{7373348246660160089: {'num': '18322'}, 3334843421982509183: {}}
{7373348246660160089: {'num': '18322'}, 3334843421982509183: {'num': '33084'}}
a with ONE has num:18322
b with TWO has num:33084
c with TWO has num:33084

工作正常。有没有办法即兴创作这种模式？或者有更好的替代方案可用于python 2.7？

Answer 1

不，你用的就是我会用的; 使用字典来表示共享状态。

您可以通过使用 dict.setdefault() 的返回值来稍微简化它，而不是忽略它：

def __init__(self, *args, **kwargs):
    context_key = hash('{0}{1}'.format(cPickle.dumps(args),cPickle.dumps(kwargs)))
    self.__dict__ = self.__shared_state.setdefault(context_key, {})

所有这些都可以封装在元类型中：

class PerArgsBorgMeta(type):
    def __new__(mcls, name, bases, attrs):
        cls = super(PerArgsBorgMeta, mcls).__new__(mcls, name, bases, attrs)
        setattr(cls, '_{}__shared_state'.format(name), {})
        return cls
    def __call__(cls, *args, **kwargs):
        instance = super(PerArgsBorgMeta, cls).__call__(*args, **kwargs)
        context_key = hash('{0}{1}'.format(cPickle.dumps(args),cPickle.dumps(kwargs)))
        state = getattr(cls, '_{}__shared_state'.format(cls.__name__))
        instance.__dict__ = state.setdefault(context_key, {})
        return instance

然后将其用作类的__metaclass__属性：

class SomeBorgClass:
    __metaclass__ = PerArgsBorgMeta

请注意，使用 hash(cPickle.dumps(kwargs)) 仍会为有冲突的字典创建不同的哈希：

>>> import cPickle
>>> hash(cPickle.dumps({'a': 42, 'i': 81}))
-7392919546006502834
>>> hash(cPickle.dumps({'i': 81, 'a': 42}))
2932616521978949826

这同样适用于集合。排序（如果您必须详尽无遗，则递归）在这里会有所帮助，但请注意，不要在作为值传入的集合和具有相同值的元组之间产生误报。每种方法都有越来越复杂的解决方法，但在某些时候，您只需要接受限制，而不是使散列代码更加复杂。