import silently kills thread

Question

I have a simple program Base.py that tests if import is able to throw an exception when the module does not exist.

# Base.py
import threading, os, time
import_is_working = False

class Launch(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.start()
    def run(self):
        global import_is_working
        try:
            print "Yes, it got into the 'try' block"
            import NON_EXISTENT_MODULE
            assert False
        except:
            print "Great, your python language is working"
            import_is_working = True
Launch()
for i in range(500):
    time.sleep(0.01)
    if import_is_working:
        break
if not import_is_working:
    print "Your import is not working."
    os._exit(4)

Sometimes I like to use this code in another module Main.py:

# Main.py
import Base

Surprisingly, it doesn't work when I run it that way:

max% python Base.py
Yes, it got into the 'try' block
Great, your python language is working
max% python Main.py
Yes, it got into the 'try' block
Your import is not working.
max%

This happens in Ubuntu, and in a clean CentOS 7.3 install too.

Answer 1

You're running into the "import lock".

The documentation mentions the limitations in importing during threads, you're violating the first one (emphasis mine):

While the import machinery is thread-safe, there are two key restrictions on threaded imports due to inherent limitations in the way that thread-safety is provided:

Firstly, other than in the main module, an import should not have the side effect of spawning a new thread and then waiting for that thread in any way. Failing to abide by this restriction can lead to a deadlock if the spawned thread directly or indirectly attempts to import a module.

Secondly, all import attempts must be completed before the interpreter starts shutting itself down. This can be most easily achieved by only performing imports from non-daemon threads created through the threading module. Daemon threads and threads created directly with the thread module will require some other form of synchronization to ensure they do not attempt imports after system shutdown has commenced. Failure to abide by this restriction will lead to intermittent exceptions and crashes during interpreter shutdown (as the late imports attempt to access machinery which is no longer in a valid state).