import threading

__spec__ = object.__getattribute__(self, '__spec__')

loader_state = __spec__.loader_state

with loader_state['lock']:

# Only the first thread to get the lock should trigger the load

# and reset the module's class. The rest can now getattr().

if object.__getattribute__(self, '__class__') is _LazyModule:

# The first thread comes here multiple times as it descends the

# call stack. The first time, it sets is_loading and triggers

# exec_module(), which will access module.__dict__, module.__name__,

# and/or module.__spec__, reentering this method. These accesses

# need to be allowed to proceed without triggering the load again.

if loader_state['is_loading'] and attr.startswith('__') and attr.endswith('__'):

return object.__getattribute__(self, attr)

loader_state['is_loading'] = True

__dict__ = object.__getattribute__(self, '__dict__')

# All module metadata must be gathered from __spec__ in order to avoid

# using mutated values.

# Get the original name to make sure no object substitution occurred

# in sys.modules.

original_name = __spec__.name

# Figure out exactly what attributes were mutated between the creation

# of the module and now.

attrs_then = loader_state['__dict__']

attrs_now = __dict__

attrs_updated = {}

for key, value in attrs_now.items():

# Code that set an attribute may have kept a reference to the

# assigned object, making identity more important than equality.

if key not in attrs_then:

attrs_updated[key] = value

elif id(attrs_now[key]) != id(attrs_then[key]):

attrs_updated[key] = value

__spec__.loader.exec_module(self)

# If exec_module() was used directly there is no guarantee the module

# object was put into sys.modules.

if original_name in sys.modules:

if id(self) != id(sys.modules[original_name]):

raise ValueError(f"module object for {original_name!r} "

"substituted in sys.modules during a lazy "

"load")

# Update after loading since that's what would happen in an eager

# loading situation.

__dict__.update(attrs_updated)

# Finally, stop triggering this method.

self.__class__ = types.ModuleType

loader_state['lock'] = threading.RLock()

loader_state['is_loading'] = False

import time

import threading

from test.support import threading_helper

load_count = 0

time.sleep(0.01) # Simulate a slow load.

self.load_count += 1

def new_module(self, source_code=None, loader=None):

if loader is None:

loader = TestingImporter()

@threading_helper.requires_working_threading()

def test_module_load_race(self):

with test_util.uncache(TestingImporter.module_name):

loader = TestingImporter()

module = self.new_module(loader=loader)

self.assertEqual(loader.load_count, 0)

class RaisingThread(threading.Thread):

exc = None

def run(self):

try:

super().run()

except Exception as exc:

self.exc = exc

def access_module():

return module.attr

threads = []

for _ in range(2):

threads.append(thread := RaisingThread(target=access_module))

thread.start()

# Races could cause errors

for thread in threads:

thread.join()

self.assertIsNone(thread.exc)

# Or multiple load attempts

self.assertEqual(loader.load_count, 1)

Protect modules loaded with :class:`importlib.util.LazyLoader` from race

conditions when multiple threads try to access attributes before the loading

is complete.