在Python中等待空闲锁的好方法（对于CPU来说）

我有一个名为“lockingValue”的泛型类，它可以被多个线程引用。这是为了防止出现竞争状况

class lockingValue(object):
    def __init__(self,value=None):
        self._locked=False
        self._value=value

    def _lock(self):
        while self._locked:
            pass
        self._locked = True

    def _unlock(self):
        self._locked = False

    def update(self,val):
        self._lock()
        self._value=val

    def value(self):
        return copy.copy(self._value)

我特别想要的是一种更好的等待锁释放的方式。以下内容可能会影响CPU，我希望避免这种情况

    def _lock(self):
        while self._locked:
            pass
        self._locked = True

更新：

我对更好、更安全的设计的建议和示例很感兴趣，可以进行这种内部进程通信和跟踪（例如，将多个线程的进度制成表格）。

请查看

正如您的代码所示，在您的

\u lock

方法中，几个线程可能在while循环中等待，如果操作系统线程调度与您合谋，那么其中多个线程可能会同时退出循环

编辑

更新了

update

，根据khachik的评论在完成时解锁。

签出

正如您的代码所示，在您的

\u lock

方法中，几个线程可能在while循环中等待，如果操作系统线程调度与您合谋，那么其中多个线程可能会同时退出循环

编辑

---

更新了

update

以根据khachik的评论在完成时解锁。

为什么不围绕Python自己的对象包装类？那么你就不必担心它是如何实现的。它甚至可以充当上下文管理器，因此您可以使用如下可爱的语法：

with myLock:
    doSomething()

---

为什么不把类包装在Python自己的对象上呢？那么你就不必担心它是如何实现的。它甚至可以充当上下文管理器，因此您可以使用如下可爱的语法：

with myLock:
    doSomething()

---

这是完全破坏，将导致灾难性的比赛条件。使用真正的互斥。感谢Glenn的警告。这完全被破坏了，将导致灾难性的比赛条件。使用真正的互斥。谢谢你的警告，格伦。谢谢你的更新。根据这一点和Glenn，我将深入搜索谨慎的方法。第二次

更新（val）

调用将被阻止，直到有人没有调用

\u unlock（）

\u unlock（）

应该在

update（）

中调用（在这种情况下不是这样，但最好养成习惯，在

finally

中调用它）或使用with语句，如下所示。@khachik你是对的，我在重做这个类时考虑得不够严谨，感谢您的输入。我想既然必须通过类方法来访问值，那么我将使用

with

语句，完全放弃lock和unlock方法。这似乎是最安全、最干净的技术。谢谢你的更新。根据这一点和Glenn，我将深入搜索谨慎的方法。第二次

更新（val）

调用将被阻止，直到有人没有调用

\u unlock（）

\u unlock（）

应该在

update（）

中调用（在这种情况下不是这样，但最好养成习惯，在

finally

中调用它）或使用with语句，如下所示。@khachik你是对的，我在重做这个类时考虑得不够严谨，感谢您的输入。我想既然必须通过类方法来访问值，那么我将使用

with

语句，完全放弃lock和unlock方法。这似乎是最安全、最干净的技术。