多线程中观察变量的Python方式？

想象一下有两个线程

observeT

和

upT

observeT

观察实例属性（

instance.a

）的值，如果其值为

7

，则应“提醒”（在本例中打印注释）。然后是线程

upT

，它一次将instance属性的值增加1（

instance.a

+=1）

但是，由于随机选择的线程继续使用Python的

Lock

，我们无法确保观测者线程（

observeT

）捕捉到

实例的值。a

增加到

7

如何确保每次

upT

释放锁后都调用观察者？请注意，保持线程

upT

和

observeT

拆分非常重要

有关详细信息，请参阅以下代码：

from threading import Lock, Thread


class MyClass():
    a: int

    def __new__(cls):
        instance = super().__new__(cls)
        instance.a = 0
        return instance

instance = MyClass()
lock = Lock()

def up():
    for i in range(100000):
        with lock:
            instance.a += 1

def observe():
    while True:
        with lock:
            a = instance.a
            if a == 7:
                print("This is 7!")
            if instance.a == 100000:
                break

observeT = Thread(target=observe)
upT = Thread(target=up)

observeT.start()
upT.start()

upT.join()
observeT.join()

---

谢谢你的帮助

这就是你要找的吗

从线程导入线程、锁、条件
类别MyClass：
定义初始化（自锁定）：
self.cond=条件（a_锁）
self.canprocedure=False
self.a=0
定义设置属性（自身、键、值）：
超级（）
如果键=='a'：
如果值==7或值==100000：
self.cond.notify（）
如果值==7：
虽然不是self.com，但可以继续：
self.cond.wait（）
lock=lock（）
实例=MyClass（锁）
def up（）：
对于范围内的i（100000）：
带锁：
实例a+=1
def observe（）：
对于instance.cond：
而实例.a！=7:
instance.cond.wait（）
打印（“这是7！”）
instance.canprocedure=True
instance.cond.notify（）
而实例.a！=100000:
instance.cond.wait（）
observeT=线程（目标=观察）
upT=线程（目标=向上）
observeT.start（）
upT.start（）
upT.join（）
observeT.join（）

输出：

This is 7!

---

这就是你要找的吗

从线程导入线程、锁、条件
类别MyClass：
定义初始化（自锁定）：
self.cond=条件（a_锁）
self.canprocedure=False
self.a=0
定义设置属性（自身、键、值）：
超级（）
如果键=='a'：
如果值==7或值==100000：
self.cond.notify（）
如果值==7：
虽然不是self.com，但可以继续：
self.cond.wait（）
lock=lock（）
实例=MyClass（锁）
def up（）：
对于范围内的i（100000）：
带锁：
实例a+=1
def observe（）：
对于instance.cond：
而实例.a！=7:
instance.cond.wait（）
打印（“这是7！”）
instance.canprocedure=True
instance.cond.notify（）
而实例.a！=100000:
instance.cond.wait（）
observeT=线程（目标=观察）
upT=线程（目标=向上）
observeT.start（）
upT.start（）
upT.join（）
observeT.join（）

输出：

This is 7!

---

非常感谢-就是这样！嗨，我还有一个问题：假设我们不能改变

up（）

，而

up（）

所做的一切都是在增加

实例。a

，就像这样：

带有cond:instance.a+=1

。。。如何使

observe（）

仍然注意到更改？@5t4cktr4c3如果是这种情况，您不能保证

observe

在

a

完全变为

7

时会注意到。不幸的是，这正是我遇到的情况。。。有什么变通方法或其他解决方案吗？@5t4cktr4c3已更新，以反映您的

up

方法未被触及的情况。非常感谢您-就是这样！嗨，我还有一个问题：假设我们不能改变

up（）

，而

up（）

所做的一切都是在增加

实例。a

，就像这样：

带有cond:instance.a+=1

。。。如何使

observe（）

仍然注意到更改？@5t4cktr4c3如果是这种情况，您不能保证

observe

在

a

完全变为

7

时会注意到。不幸的是，这正是我遇到的情况。。。任何变通方法或其他解决方案？@5t4cktr4c3已更新，以反映未触及

up

方法的情况。旁注：主线程调用

upT.start（）

，然后立即调用

upT.join（）

。这意味着，主线程不会与

upT

线程同时执行任何操作。但是，并发性是拥有线程的唯一原因。那么为什么要创建

upT

线程呢？主线程已经存在。为什么不使用它呢？为什么不直接做：

observeT.start（）；up（）；observeT.join（）

？旁注：主线程调用

upT.start（）

，然后它立即调用

upT.join（）

。这意味着，主线程不会与

upT

线程同时执行任何操作。但是，并发性是拥有线程的唯一原因。那么为什么要创建

upT

线程呢？主线程已经存在。为什么不使用它呢？为什么不直接做：

observeT.start（）；up（）；observeT.join（）

？