Daemon Threads

diagram a daemon thread does not get to finish mermaid

  flowchart TD
  A["main thread finishes"] --> B{"any non-daemon threads still running?"}
  B -->|yes| C["the process waits for them"]
  C --> D["they run to completion"]
  B -->|no| E["the interpreter shuts down"]
  E --> F["daemon threads are killed mid-statement"]
  F --> G["no finally, no cleanup, no flush"]
  G --> H["a half-written file, a held lock, a lost record"]
  D --> I["use non-daemon + join() for work that must complete"]
  F --> J["use daemon only for work that is safe to abandon"]

When the last non-daemon thread ends, the interpreter shuts down and kills every daemon thread wherever it happens to be -- no exception raised in it, no finally block run, no flush. That is right for a background heartbeat and wrong for anything writing a file.

Measured: the same worker, one flag apart

A worker that sleeps in a loop for one second and then prints FINISHED, with the main thread exiting immediately after starting it:

daemon=	Output
True	(nothing — the thread was killed at interpreter shutdown)
False	FINISHED — the process stayed alive until the worker was done

The daemon thread was not asked to stop and did not get a chance to clean up; it simply ceased to exist. Nothing was logged and no exception was raised.

So the rule is about consequences, not about tidiness: if abandoning the work half-done is harmless, a daemon thread is right. If it is writing a file, holding a lock, or has a record in flight, use a normal thread and join() it — or give it a threading.Event to check so it can shut itself down deliberately.

What is a daemon thread?

A daemon thread is a background thread.

• If only daemon threads are left running, Python can exit.
• Non-daemon threads keep the program alive.

Example

daemon_thread.py

import threading
import time
 
 
def background():
    while True:
        print("background working...")
        time.sleep(0.5)
 
 
t = threading.Thread(target=background, daemon=True)
t.start()
 
time.sleep(2)
print("Main thread exiting")

When to use daemon threads

• logging/reporting loops
• background monitoring

When NOT to use them

Don’t use daemon threads for work that must finish (e.g., writing critical data).

sketch The moment the main thread exits p5.js Pause Restart

Two runs of the same worker, which needs one second and prints FINISHED at the end. The main thread starts it and immediately exits. Watch what happens at the instant main finishes: the non-daemon run keeps the process alive to the end, and the daemon run is cut off wherever it happens to be. Neither raises anything.

Check yourself

pch.quizTag pch.quizDefaultTitle

1. A daemon thread is halfway through writing a file when the main thread finishes. What happens?

   A The process waits for it to finish B It is killed where it stands — no exception, no `finally`, no flush C It raises SystemExit inside the thread D The file is flushed automatically
   pch.quizShowAnswer

   B — It is killed where it stands — no exception, no `finally`, no flush — Measured: the same worker printed FINISHED with `daemon=False` and printed nothing with `daemon=True`. Interpreter shutdown does not ask daemon threads to stop; it stops existing.

2. When is a daemon thread the right choice?

   A Whenever you want the program to exit quickly B When abandoning the work half-done is harmless C For anything that writes to disk D For CPU-bound work
   pch.quizShowAnswer

   B — When abandoning the work half-done is harmless — A heartbeat, a metrics poller or a cache warmer can be abandoned safely. Anything holding a lock, writing a file, or with a record in flight cannot.

3. How do you make sure a worker thread finishes before the program exits?

   A Set `daemon=True` and call `join()` B Leave it non-daemon (the default) and `join()` it C Use `time.sleep()` in the main thread D Call `thread.stop()`
   pch.quizShowAnswer

   B — Leave it non-daemon (the default) and `join()` it — A non-daemon thread keeps the process alive by itself; `join()` makes the wait explicit. There is no `stop()` — a thread must be asked to finish, usually via a `threading.Event` it checks.

4. What is the cleanest way to tell a long-running thread to shut down?

   A Kill it from outside B Give it a `threading.Event` it checks periodically C Raise an exception in the main thread D Make it a daemon and exit
   pch.quizShowAnswer

   B — Give it a `threading.Event` it checks periodically — Cooperative shutdown is the only reliable kind. The thread checks the flag at a point where stopping is safe, then unwinds normally — running its `finally` blocks.

🧪 Try It Yourself

Exercise 1 – Create a Daemon Thread

pch.exerciseTag pch.exerciseTitle

Exercise 2 – Non-Daemon vs Daemon

pch.exerciseTag pch.exerciseTitle

Exercise 3 – Main Thread is Not a Daemon

pch.exerciseTag pch.exerciseTitle