What does sys.exit really do with multiple threads?

by

(Paraphrasing what’s in the Python 2 documentation for Thread Objects)

Normally a Python program exits only when there’s nothing but daemon✶
threads (ignoring itself) left running. The “main thread” object which corresponds to the initial thread of control in the program isn’t a daemon thread. Threads created using threading.Thread inherit their daemonic status from the creating thread, so if that’s the main thread, they will also be non-daemonic.

This means that by default any threads created and started by your main program will prevent it from exiting if they are still running when the main thread is terminated (by sys.exit() or simply by just hitting the end of its code). In other words, the program exits only when no alive non‑daemon threads (i.e. only daemon threads) are left.

You can override this default behavior by explicitly setting✶✶ the
daemon property of any
created thread objects to True before starting it.

if __name__=="__main__":
    t = threading.Thread(target=threadrun)
    t.daemon = True  # Explicitly set property.
    t.start()
    sys.exit()

Which will allow the program to actually end when sys.exit() is called (although calling it explicitly like that would not be necessary since presumably the code above would be at the end of the script anyway).

✶ A daemon thread is one that runs in the background and does not prevent the interpreter from exiting. See Daemon Threads Explanation.

✶✶ In Python 3.3, a daemon keyword argument with a default value of None was added to the Thread
class constructor
which means that, starting from that version onwards, you can simply use:

    # Sets whether the thread is daemonic via "daemon" keyword argument.
    t = threading.Thread(target=threadrun, daemon=True)

However, doing it separately via an explicit attribute assignment statement
still works, and would therefore be the more version-portable way of
doing it.

More Related Contents:

  1. How to use asyncio with threading in Python is Method threading.Timer
  2. Multiprocessing vs Threading Python [duplicate]
  3. Are lists thread-safe?
  4. Catch a thread’s exception in the caller thread?
  5. thread starts running before calling Thread.start
  6. How to use multiprocessing queue in Python?
  7. How to make built-in containers (sets, dicts, lists) thread safe?
  8. Using win32com with multithreading
  9. Threads and tkinter
  10. Multithreaded web server in python
  11. Program freezing during the execution of a function in Tkinter
  12. How to run multiple jobs in one Sparkcontext from separate threads in PySpark?
  13. Kill a running subprocess call
  14. Most Pythonic way to kill a thread after some period of time
  15. How to use threading in Python?
  16. Running a Tkinter form in a separate thread
  17. Python creating a shared variable between threads
  18. How to start threads at the same time in Python [duplicate]
  19. Is a variable swap guaranteed to be atomic in python?
  20. Restarting a thread in Python
  21. Using multiprocessing.Process with a maximum number of simultaneous processes
  22. How to use sys.exit() in Python
  23. Threading in python using queue
  24. Execute Python function in Main thread from call in Dummy thread
  25. How do I create a file in python without overwriting an existing file
  26. How to implement a Lock with a timeout in Python 2.7
  27. Why does Paramiko hang if you use it while loading a module?
  28. Python: Why is threaded function slower than non thread
  29. Trigger an event when clipboard content changes
  30. Why doesn’t a string in parentheses make a tuple with just that string? [duplicate]

Leave a Comment