2

尝试创建一个可以使用 threading.lock 锁定对象的类：

class ObjectLock(object):
    def __init__(self):
        self._lock = threading.Lock()
        self._value = False
    def __str__(self):
        self.acquire() 
        try: 
            if(self._value):
                return self._value
            else:
                return self._value
        finally: 
            self.release() 
    def __enter__(self):
        self.acquire()
    def __exit__(self, type, value, traceback):
        self.release()
    def acquire(self):   
        self._lock.acquire()
    def release(self):
        self._lock.release() 
    def locked(self):
        return self._lock.locked()

lock = ObjectLock()

print(lock)
with lock:
    print (lock)

问题是我正在尝试实施“with”。如果在“with”块中调用方法（例如str，则重新获取锁......这很糟糕。当我知道我在锁中工作时，我是否必须创建一组单独的方法来调用?

4

4 回答 4

2

首先，我不明白为什么__str__需要获取锁，所以我认为前提是没有实际意义的。

如果您确定内部锁定是可取的，请考虑使用可重入锁，例如threading.RLock. 这样，单个线程将能够根据需要多次获取锁而不会死锁。

于 2013-03-04T19:10:28.383 回答
1

而不是使用threading.Lock，使用threading.Rlock。这是一个可重入锁，它允许同一个线程多次获取锁。

于 2013-03-04T19:10:56.277 回答
0

使用可重入锁（threading.RLock）

于 2013-03-04T19:10:44.080 回答
0

当我知道自己在锁中工作时，是否必须创建一组单独的方法来调用？

不，这已经为您完成了。类threading.RLock（可重入锁）会为您处理这个问题，它实现与Lock.

这个R角色会神奇地挥舞你的问题。

于 2013-03-04T19:20:47.413 回答