python - 如果/我应该使用线程来更新全局变量怎么办。[Pythonic 方式]

Question

我有一个更新全局/类变量的函数。那么，定期调用子线程等函数后需要注意什么？(异步方式)

或者，有什么建议可以避免使用这种模式吗？ (悲哀的方式)

import time
import threading

# through global variable or class variable
_a = 123


def update_a():        # may be called more than once
    "slow updating process"
    time.sleep(3)
    global _a
    _a += 10
    return

if __name__ == '__main__':
    print(_a)
    th = threading.Thread(target=update_a)
    th.setDaemon(True)
    th.start()
    print(_a)
    # updating aynchrounously
    time.sleep(5)
    print(_a)

Answer 1

首先，在 Python 中，线程是完全应该避免的事情，但如果你真的想这样做，我会这样做。首先，使用lock创建一个线程安全对象。 :

class ThreadSafeValue(object):
    def __init__(self, init):
        self._value = init
        self._lock = threading.Lock()

    def atomic_update(self, func):
        with self._lock:
            self._value = func(self._value)

    @property
    def value(self):
        return self._value

然后我将其传递给线程目标函数:

def update(val):
    time.sleep(3)
    val.atomic_update(lambda v: v + 10)

def main():
    a = ThreadSaveValue(123)
    print a.value
    th = threading.Thread(target=update, args=(a,))
    th.daemon = True
    th.start()
    print a.value
    th.join()
    print a.value

if __name__ == '__main__':
    main()

这样就可以避免全局变量并确保线程安全。