python 中的头部安全对象和字典类型

Question

我有两个关于在 python 中创建线程安全类型的问题，以及一个关于多重继承的相关问题。

1）在我的线程应用程序中使用以下子类作为一种“惰性”线程安全类型是否有任何问题？我意识到，无论谁设置了可能被其他线程更改的值，都有责任确保这些值也是线程安全的。

2）我的另一个问题是，在典型的安装中，Python 中是否存在对这些类型更谨慎的替代方案。

示例：

from threading import Lock
from __future__ import with_statement

class safedict(dict):
    def __init__(self,*args,**kwargs):
        self.mylock=Lock(); 
        super(safedict, self).__init__(*args, **kwargs)
    def __setitem__(self,*args,**kwargs):
        with self.mylock:
            print " DEBUG: Overloaded __setitem__ has the lock now."
            super(safedict,self).__setitem__(*args,**kwargs)


class safeobject(object):
    mylock = Lock(); # a temporary useless lock, until we have a proper instance.
    def __init__(self,*args,**kwargs):
        self.mylock=Lock(); 
        super(safeobject, self).__init__(*args, **kwargs)
    def __setattr__(self,*args,**kwargs):
        with self.mylock:
            print " DEBUG: Overloaded __setattr__ has the lock now."
            super(safeobject,self).__setattr__(*args,**kwargs)

3）如果上面定义的两种类型都可以被认为是相当安全的，那么使用多重继承来创建支持这两种修改混合的类型会面临什么负面影响，以及我的示例是否继承了最优顺序？

示例：

class safedict2(safeobject,dict):
    def __setitem__(self,*args,**kwargs):
        with self.mylock:
            print " DEBUG: Overloaded __setitem__ has the lock now."
            super(safedict2,self).__setitem__(*args,**kwargs)

编辑： 这是另一种类型继承前两种类型并使用 ipython 进行测试的另一个示例。

In [304]: class safedict3(safeobject,safedict):
   .....:         pass
   .....: 

In [305]: d3 = safedict3()
 DEBUG: Overloaded __setattr__ has the lock now.
 DEBUG: Overloaded __setattr__ has the lock now.

In [306]: d3.a=1
 DEBUG: Overloaded __setattr__ has the lock now.

In [307]: d3['b']=2
 DEBUG: Overloaded __setitem__ has the lock now.

In [308]: d3
Out[308]: {'b': 2}

Answer 1

至于你的第一个问题和第二个问题， dict、list 等类型已经是线程安全的。您不必为它们添加线程安全性。不过您可能会发现这很有用。它是一个装饰器，基本上实现了 Java 中的 synchronized 关键字，使用函数作用域来定义关键部分。使用类似的方法也可以创建一个面向threading.Condition的装饰器。

import threading

def tryfinally(finallyf):
  u"returns a decorator that adds try/finally behavior with given no-argument call in the finally"
  def decorator(callable):
    def execute(*args, **kwargs):
      try: result = callable(*args, **kwargs)
      finally: finallyf()
      return result
    return execute
  return decorator

def usinglock(lock):
  u"returns a decorator whose argument will acquire the given lock while executing"
  def decorator(function):
    body = tryfinally(lock.release)(function)
    def execute(*args, **kwargs):
      lock.acquire()
      return body(*args, **kwargs)
    return execute
  return decorator

def synchronized(function):
  u"decorator; only one thread can enter the decorated function at a time; recursion is OK"
  return usinglock(threading.RLock())(function)

像这样使用它（如果过度使用它，请注意死锁）：

@synchronized
def foo(*args):
  print 'Only one thread can enter this function at a time'

在第三个问题上， Python教程指出继承属性的搜索顺序是深度优先、左优先。因此，如果您继承 (myclass, dict) ，则应使用 myclass 中的 __setitem__ 方法。 （在旧版本的 Python 中，教程中的同一部分暗示这种选择是任意的，但现在它似乎是经过深思熟虑的。）

我从发布的源代码中弗洛伊德式的分号错误中猜测您是新手Python，但在 Java 或 C# 方面经验丰富。如果是这样，您需要记住，属性（方法）解析发生在 Python 的运行时，并且类以及实例都是可以在以下位置检查/探索的一流对​​象：运行时间。

首先搜索实例属性字典，然后搜索类属性，然后启动父类搜索算法。这是通过（概念上）相当于重复的 hasattr(class_or_instance, attribute) 调用来完成的。

下面确认了对于“新式”类（从 object 继承的类，在 2.x 语言规范中是可选的），每次查找属性时都会发生此解析。当创建类（或子类）或创建实例时，不会完成此操作。 （这是在版本 2.7.2 中完成的。）

>>> class Foo(object):
...   def baz(self):
...     print 'Original Foo.baz'
...
>>> class Bar(Foo): pass
...
>>> def newprint(self):
...   print 'New Foo.baz'
...
>>> x = Foo()
>>> y = Bar()
>>> Foo.baz = newprint
>>> a = Foo()
>>> b = Bar()
>>> map(lambda k: k.baz(), (x, y, a, b))
New Foo.baz
New Foo.baz
New Foo.baz
New Foo.baz
[None, None, None, None]

替换类 Foo 的方法会更改已定义的子类和已创建的实例的行为。