Question

我一直在寻找有关线程同步的一些解释。我发现要进行研究时会遇到挑战，我将在这里提供解决方案。基本上有一个带有数值的类，您可以对其进行加减。如果有许多线程正在访问该实例，则应等待所有线程完成后再返回最终值。我的实现如下：

from threading import Lock, Thread
from time import sleep
import sys

class ClassA(object):

   def with_lock():
        def wrapper(func):
            def wrapped(self, *args):
                with self.lock:
                    return func(self, *args)
            return wrapped
        return wrapper

   def __init__(self, balance = 0):
      self.balance = balance
      self.lock = Lock()

   def get_balance(self):
      return self.balance

   @with_lock()
   def add(self):
      self.balance += 1

   @with_lock()
   def sub(self):
      self.balance -= 1


if __name__ == "__main__":

   sys.setswitchinterval(1e-12)

   value = 10

   def foo():
      a.add()
      sleep(0.01)
      a.sub()

   a = ClassA(value)

   threads = [Thread(target=foo) for _ in range(1000)]
   for thread in threads:
      thread.start()
   for thread in threads:
      thread.join()

   print(a.get_balance()) # should return "value"

装饰器“ with_lock”的实现在互联网上的其他实现中也可以找到，但是我不理解。

关于这部分：

with self.lock:
    return func(self, *args)

我搜索了有关Lock文档，它表明self.lock将是具有获取和释放方法的Lock对象。我能理解'with'语句会等到线程被释放吗？还是有其他行为？

最后的打印一直等到所有线程完成，但是get_balance没有装饰器“ with_lock”。为什么要等到线程完成？

使用锁对象的多线程同步

0 个答案: