在线程中使用全局变量

Question

如何与线程共享全局变量？

我的 Python 代码示例是：

from threading import Thread
import time
a = 0  #global variable

def thread1(threadname):
    #read variable "a" modify by thread 2

def thread2(threadname):
    while 1:
        a += 1
        time.sleep(1)

thread1 = Thread( target=thread1, args=("Thread-1", ) )
thread2 = Thread( target=thread2, args=("Thread-2", ) )

thread1.join()
thread2.join()

我不知道如何让两个线程共享一个变量。

Answer 1

您只需在thread2 中将a 声明为全局变量，这样您就不会修改该函数的本地a。

def thread2(threadname):
    global a
    while True:
        a += 1
        time.sleep(1)

在thread1中，你不需要做任何特别的事情，只要你不尝试修改a的值（这会创建一个隐藏全局变量的局部变量；使用@987654327 @如果你需要）>

def thread1(threadname):
    #global a       # Optional if you treat a as read-only
    while a < 10:
        print a

Answer 2

在函数中：

a += 1

编译器会将其解释为assign to a => Create local variable a，这不是您想要的。它可能会失败并出现a not initialized 错误，因为（本地）a 确实没有被初始化：

>>> a = 1
>>> def f():
...     a += 1
... 
>>> f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in f
UnboundLocalError: local variable 'a' referenced before assignment

使用global 关键字（非常不受欢迎，并且有充分的理由）你可能会得到你想要的，就像这样：

>>> def f():
...     global a
...     a += 1
... 
>>> a
1
>>> f()
>>> a
2

然而，一般来说，您应该避免使用会很快变得失控的全局变量。对于多线程程序尤其如此，因为您没有任何同步机制让您的thread1 知道a 何时被修改。简而言之：线程是复杂的，当两个（或多个）线程处理相同的值时，您不能期望对事件发生的顺序有一个直观的理解。语言、编译器、操作系统、处理器……都可以发挥作用，并出于速度、实用性或任何其他原因决定修改操作顺序。

这种事情的正确方法是使用Python共享工具（locks 和朋友），或者更好的是，通过Queue 而不是共享数据来交流数据，例如像这样：

from threading import Thread
from queue import Queue
import time

def thread1(threadname, q):
    #read variable "a" modify by thread 2
    while True:
        a = q.get()
        if a is None: return # Poison pill
        print a

def thread2(threadname, q):
    a = 0
    for _ in xrange(10):
        a += 1
        q.put(a)
        time.sleep(1)
    q.put(None) # Poison pill

queue = Queue()
thread1 = Thread( target=thread1, args=("Thread-1", queue) )
thread2 = Thread( target=thread2, args=("Thread-2", queue) )

thread1.start()
thread2.start()
thread1.join()
thread2.join()

Answer 3

好吧，运行示例：

警告！永远不要在家里/工作中这样做！ 只在教室里；）

使用信号量、共享变量等来避免紧急情况。

from threading import Thread
import time

a = 0  # global variable


def thread1(threadname):
    global a
    for k in range(100):
        print("{} {}".format(threadname, a))
        time.sleep(0.1)
        if k == 5:
            a += 100


def thread2(threadname):
    global a
    for k in range(10):
        a += 1
        time.sleep(0.2)


thread1 = Thread(target=thread1, args=("Thread-1",))
thread2 = Thread(target=thread2, args=("Thread-2",))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

和输出：

Thread-1 0
Thread-1 1
Thread-1 2
Thread-1 2
Thread-1 3
Thread-1 3
Thread-1 104
Thread-1 104
Thread-1 105
Thread-1 105
Thread-1 106
Thread-1 106
Thread-1 107
Thread-1 107
Thread-1 108
Thread-1 108
Thread-1 109
Thread-1 109
Thread-1 110
Thread-1 110
Thread-1 110
Thread-1 110
Thread-1 110
Thread-1 110
Thread-1 110
Thread-1 110

如果时机合适，a += 100 操作将被跳过：

处理器在 T a+100 处执行并得到 104。但它停止了，并跳转到下一个线程 在这里，At T+1 执行 a+1，旧值为 a，a == 4。所以它计算出 5。 跳回（在 T+2 处），线程 1，并将a=104 写入内存。 现在回到线程 2，时间是 T+3 并将a=5 写入内存。 瞧！下一条打印指令将打印 5 而不是 104。

非常讨厌的错误要被复制和捕获。

Answer 4

应该考虑使用锁，例如threading.Lock。请参阅lock-objects 了解更多信息。

接受的答案可以由 thread1 打印 10，这不是您想要的。你可以运行下面的代码更容易理解这个bug。

def thread1(threadname):
    while True:
      if a % 2 and not a % 2:
          print "unreachable."

def thread2(threadname):
    global a
    while True:
        a += 1

使用锁可以禁止a在多次读取时更改：

def thread1(threadname):
    while True:
      lock_a.acquire()
      if a % 2 and not a % 2:
          print "unreachable."
      lock_a.release()

def thread2(threadname):
    global a
    while True:
        lock_a.acquire()
        a += 1
        lock_a.release()

如果线程长时间使用该变量，首先将其复制到局部变量是一个不错的选择。

Answer 5

非常感谢 Jason Pan 提出这种方法。 thread1 if 语句不是原子的，因此当该语句执行时，thread2 可能会侵入 thread1，从而允许访问不可访问的代码。我已将之前帖子中的想法整理成一个完整的演示程序（如下），我使用 Python 2.7 运行该程序。

通过一些深思熟虑的分析，我相信我们可以获得进一步的洞察力，但就目前而言，我认为展示非原子行为遇到线程时会发生什么很重要。

# ThreadTest01.py - Demonstrates that if non-atomic actions on
# global variables are protected, task can intrude on each other.
from threading import Thread
import time

# global variable
a = 0; NN = 100

def thread1(threadname):
    while True:
      if a % 2 and not a % 2:
          print("unreachable.")
    # end of thread1

def thread2(threadname):
    global a
    for _ in range(NN):
        a += 1
        time.sleep(0.1)
    # end of thread2

thread1 = Thread(target=thread1, args=("Thread1",))
thread2 = Thread(target=thread2, args=("Thread2",))

thread1.start()
thread2.start()

thread2.join()
# end of ThreadTest01.py

正如预测的那样，在运行示例时，有时实际上会到达“无法访问”的代码，从而产生输出。

补充一下，当我将锁获取/释放对插入线程 1 时，我发现打印“无法访问”消息的可能性大大降低。为了看到消息，我将睡眠时间减少到 0.01 秒，并将 NN 增加到 1000。

在线程 1 中有一个锁定获取/释放对，我根本没想到会看到该消息，但它就在那里。在我将锁定获取/释放对也插入 thread2 后，该消息不再出现。在后符号中，thread2 中的增量语句可能也是非原子的。