🍴 Pattern 7: Start Methods

Three Ways to Make a Child

When you call Process.start() or open a pool, Python has to bring a new worker into existence. There are three mechanisms, and which one you get depends on your OS and Python version — not on your code. They behave very differently, and code that quietly relies on one will explode on another.

• fork — the child is a near-instant copy of the parent's whole memory (copy-on-write). Fast, no re-import; the child inherits everything — globals, imported modules, open file descriptors, sockets. Unix only.
• spawn — a fresh Python interpreter that re-imports your module and receives only the explicitly-passed, picklable arguments. Slower to start, clean slate, inherits nothing. Default on macOS (since 3.8) and Windows; the only option on Windows.
• forkserver — a small, clean server process is forked once at the start, then it forks workers on request. Avoids copying a big or thread-heavy parent while keeping fork's speed. Unix only.

fork vs spawn, Side by Side

The Defaults Are Moving — Don't Assume fork

For years, tutorials assumed fork because it was the Linux default. That assumption is being actively dismantled because fork is unsafe in modern, multi-threaded programs.

Setting the Start Method Explicitly

Two ways. set_start_method mutates a global for the whole program and can only be called once. get_context is preferred — it hands you a context object whose Process/Pool use that method without touching global state, so libraries don't fight each other.

import multiprocessing as mp

def worker(x):
    print(f"got {x}")

if __name__ == "__main__":
    # Option A: global switch — call ONCE, under __main__, before starting anything.
    mp.set_start_method("spawn")
    p = mp.Process(target=worker, args=(1,))
    p.start(); p.join()

import multiprocessing as mp

def worker(x):
    print(f"got {x}")

if __name__ == "__main__":
    # Option B (preferred): a context object — no global mutation.
    ctx = mp.get_context("spawn")
    p = ctx.Process(target=worker, args=(2,))   # ctx.Process, ctx.Pool, ctx.Queue ...
    p.start(); p.join()

    with ctx.Pool(processes=4) as pool:         # the pool also uses spawn
        pool.map(worker, range(4))

Consequence 1: Why Every Example Has the __main__ Guard

With spawn, the child re-imports your module to rebuild the worker. If your launch code sits at module top level, the child re-runs it on import — and spawns children that spawn children, forever.

import multiprocessing as mp

def worker():
    print("working")

# ❌ At top level: re-runs on every spawn re-import → explosion / RuntimeError.
# ✅ Guarded: only the ORIGINAL process has __name__ == "__main__".
if __name__ == "__main__":
    p = mp.Process(target=worker)
    p.start()
    p.join()

This is the reason every example in this whole guide wraps its launch in if __name__ == "__main__": — it's a portability requirement, not a stylistic one.

Consequence 2: fork + Threads = Deadlock

This is subtle because you often don't hold the lock yourself — a library does, in a background thread. It classically bites the logging module (which locks internally) and anything that runs threads under the hood. This exact hazard is why macOS abandoned fork and why Python 3.14 is retiring it as the Linux default in favor of forkserver.

import logging, multiprocessing as mp

def worker():
    logging.info("hi from child")   # under fork, can deadlock on an inherited locked handler

# Safe fix: pick a start method that gives the child a clean slate.
if __name__ == "__main__":
    ctx = mp.get_context("spawn")   # or "forkserver" on Unix
    p = ctx.Process(target=worker)
    p.start(); p.join()

Consequence 3: With spawn, Globals Are Not Inherited

Under fork a child can read a module-level global the parent built (a loaded model, a config dict) because it inherited the whole memory. Under spawn the child rebuilds the module by importing it — so module-level state created inside the __main__ block, or mutated at runtime, is gone. Whatever a worker needs must either be passed in as an argument or reconstructed in an initializer.

import multiprocessing as mp

_MODEL = None   # rebuilt per worker under spawn — NOT inherited from the parent

def init_worker(config):
    global _MODEL
    _MODEL = load_model(config)     # build the expensive thing ONCE per worker

def predict(item):
    return _MODEL.score(item)       # reuse the per-worker global

def load_model(config):
    return config                   # stand-in

if __name__ == "__main__":
    ctx = mp.get_context("spawn")
    with ctx.Pool(4, initializer=init_worker, initargs=({"weights": "..."},)) as pool:
        print(pool.map(predict, range(8)))

Key Takeaways