class 来自导入模块线程的变量初始化在 Python 中是否安全？

Question

我知道 class 变量初始化发生在导入时。如果是这样，在下面的代码中，class A 的 class 变量初始化是否会导致竞争条件？

a.py:

class A:
    # Static code here...
    pass

b.py:

class B:
    def func(self):
        from a import A

c.py:

import threading
from b import B

b1 = B()
b2 = B()

t1 = threading.Thread(target=b1.func)
t2 = threading.Thread(target=b2.func)

t1.start()
t2.start()

t1.join()
t2.join()

航站楼：

$ python c.py

Answer 1

由于 Global Interpreter Lock，我相信这里没有数据竞争（假设您使用的是 CPython 或类似的实现）。在任何给定时间，只有一个线程可以执行 Python 字节码。

然而，两个线程中的哪一个实际上最终首先导入A不能（或至少不应该）依赖。

Answer 2

在 importlib 的 CPython 实现中，C 端有一个线程锁，但为了确定，我运行以下脚本：

导入的文件：

import time
print('importing, in imported file')
time.sleep(2) # drop the GIL
print('finished importing, in imported file')

正在导入文件：

import threading

def import_other_file():
    print('going to import')
    import ex12
    print('finished importing')

t1 = threading.Thread(target=import_other_file)
t2 = threading.Thread(target=import_other_file)

t1.start()
t2.start()

t1.join()
t2.join()

输出：

going to import
going to import
importing, in imported file
finished importing, in imported file
finished importing
finished importing

does the class variable initialization of class A result in race conditions?

所以NO，不会因为C端的锁而出现race condition

class 来自导入模块线程的变量初始化在 Python 中是否安全？

Is class variable initialization from an imported module thread safe in Python?

python

multithreading

thread-safety

class-variables

python-3.x