我的代码是
import threading
counter = 0
def worker():
global counter
counter += 1
if __name__ == "__main__":
threads = []
for i in range(1000):
t = threading.Thread(target = worker)
threads.append(t)
t.start()
for t in threads:
t.join()
print counter
因为我不使用锁来保护共享资源,即counter变量,我期望结果是一个小于1000的数字,但是计数器总是1000,我不知道为什么。
counter += 1
是 Python 中的原子操作吗?
Python 中哪些操作是使用 GIL 的原子操作?
不要指望
x += 1
是线程安全的。这是不起作用的示例(请参阅 Josiah Carlson 的评论):
import threading
x = 0
def foo():
global x
for i in xrange(1000000):
x += 1
threads = [threading.Thread(target=foo), threading.Thread(target=foo)]
for t in threads:
t.daemon = True
t.start()
for t in threads:
t.join()
print(x)
如果你拆开
foo
:
In [80]: import dis
In [81]: dis.dis(foo)
4 0 SETUP_LOOP 30 (to 33)
3 LOAD_GLOBAL 0 (xrange)
6 LOAD_CONST 1 (1000000)
9 CALL_FUNCTION 1
12 GET_ITER
>> 13 FOR_ITER 16 (to 32)
16 STORE_FAST 0 (i)
5 19 LOAD_GLOBAL 1 (x)
22 LOAD_CONST 2 (1)
25 INPLACE_ADD
26 STORE_GLOBAL 1 (x)
29 JUMP_ABSOLUTE 13
>> 32 POP_BLOCK
>> 33 LOAD_CONST 0 (None)
36 RETURN_VALUE
您会看到有一个
LOAD_GLOBAL
用于检索 x
的值,有一个 INPLACE_ADD
,然后有一个 STORE_GLOBAL
。
如果两个线程连续
LOAD_GLOBAL
,那么它们可能都会加载x
的相同值。然后它们都增加到相同的数字,并存储相同的数字。因此,一个线程的工作会覆盖另一个线程的工作。这不是线程安全的。
如您所见,如果程序是线程安全的,
x
的最终值将为 2000000,但您几乎总是得到小于 2000000 的数字。
如果添加锁,您将得到“预期”答案:
import threading
lock = threading.Lock()
x = 0
def foo():
global x
for i in xrange(1000000):
with lock:
x += 1
threads = [threading.Thread(target=foo), threading.Thread(target=foo)]
for t in threads:
t.daemon = True
t.start()
for t in threads:
t.join()
print(x)
产量
2000000
我认为您发布的代码没有出现问题的原因是:
for i in range(1000):
t = threading.Thread(target = worker)
threads.append(t)
t.start()
是因为与生成新线程所需的时间相比,您的
worker
完成得非常快,实际上线程之间不存在竞争。在上面 Josiah Carlson 的示例中,每个线程在 foo
中花费了大量时间,这增加了线程冲突的机会。