👻 Pattern 8: Daemon Threads & Lifecycle

The Thread Lifecycle

A thread isn't just "running" or "not". It moves through a handful of states, and knowing them makes sense of start(), join(), and why a thread can be "alive" while doing absolutely nothing (blocked on a lock or sleeping).

• New — constructed, but start() not yet called. Nothing runs.
• Runnable — start() was called; the OS may schedule it, but it isn't on a CPU this instant.
• Running — actually executing (holds the GIL right now in CPython).
• Blocked / Waiting — alive but parked: waiting on a lock, on I/O, or in time.sleep. This is where I/O-bound threads spend most of their life (GIL released).
• Terminated — target returned or raised. The thread is done and can't be restarted.

Daemon vs Non-Daemon: Who Keeps the Program Alive

Every thread is either a daemon or not. The rule is simple and it's the whole point of the flag:

import threading, time

def background():
    while True:
        print("daemon tick")
        time.sleep(0.5)

t = threading.Thread(target=background, daemon=True)  # set BEFORE start()
t.start()

time.sleep(1.2)
print("main is done")
# Process exits here. The daemon is killed mid-loop — no more ticks, no cleanup.

Why You Normally join() Non-Daemon Threads

A non-daemon thread keeps the process alive on its own — so you don't have to join it to avoid killing it. You join() for a different reason: to know when it's actually done and to surface its outcome before you move on (or before the interpreter tears down and starts closing things out from under it).

import threading, time

def do_work(name):
    time.sleep(1)
    print(f"{name} finished writing its file")

t = threading.Thread(target=do_work, args=("writer",))   # non-daemon (default)
t.start()

# ... do other main-thread work here ...

t.join()          # block until the writer is truly done
print("safe to continue — the file is fully written")

Inspecting Threads at Runtime

The threading module gives you a small toolbox for introspection — invaluable for logging, debugging hangs, and health checks.

import threading, time

def worker():
    print("in:", threading.current_thread().name)  # the thread running THIS code
    time.sleep(0.5)

t = threading.Thread(target=worker, name="Heartbeat")  # name it — shows up in logs & tracebacks
t.start()

print("alive?      ", t.is_alive())          # True while running, False once terminated
print("this thread:", threading.current_thread().name)  # "MainThread"
print("active:     ", threading.active_count())         # how many threads are alive right now
print("all threads:", [th.name for th in threading.enumerate()])  # list every alive thread

t.join()
print("alive now?  ", t.is_alive())          # False — terminated

• is_alive() — True from after start() until target returns/raises.
• name= — give threads meaningful names; they appear in tracebacks and logs and turn "which thread hung?" from guesswork into a glance.
• threading.current_thread() — the Thread object executing the current code.
• threading.active_count() — number of currently alive Thread objects (includes the main thread and any daemons).
• threading.enumerate() — a list of all alive threads; iterate it to see exactly what's running.

The Main Thread

Your program starts life with one thread already running: the main thread (threading.main_thread(), named "MainThread"). It's non-daemon, it's the one that runs your top-level code, and it's the only thread that can receive signals like KeyboardInterrupt (Ctrl-C).

Real-World: When a Daemon Is the Right Call (and When It Isn't)

import threading, time

def heartbeat():
    while True:
        # send_ping()  # cheap, idempotent, safe to be cut off at any moment
        time.sleep(5)

threading.Thread(target=heartbeat, name="Heartbeat", daemon=True).start()
# main thread carries on; heartbeat dies quietly whenever the app exits

Key Takeaways