等待CPU自由锁定的好方法（对于CPU）

Question

I have a generic class called "lockingValue" that may be referenced by several threads. This is to prevent a race condition.

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)

What I'm looking for specifically is a nicer way to wait for the lock to become free. The following is liable to peg the CPU and I would like to avoid it.

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

Update:

I am interested in suggestions and examples of a better & safer design to do this sort of inner-process communication & tracking (tabulating progress across many threads for example).

Answer 1

Check out threading.Lock() .

import threading

class lockingValue(object):
    def __init__(self,value=None):
        self._lock = threading.Lock()
        self._value = value

    def _lock(self):
        self._lock.acquire()

    def _unlock(self):
        self._lock.release()

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

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

As your code stands right now, in your _lock method, several threads could be waiting in the while loop, and multiple of them could make it out of the loop simultaneously if the OS thread scheduling conspired against you.

Edit

Updated update to unlock when finished based on khachik's comment.

Answer 2

Why not wrap your class around Python's own Lock object? Then you don't have to worry about how it's implemented. It even acts as a context manager, so you can use cute syntax like this:

with myLock:
    doSomething()