Concurrency

Enables running a function in a separate thread of execution without blocking the calling thread.

I/O-bound tasks: downloading files or making network requests without freezing the main program Background processing: running periodic cleanup or monitoring loops alongside the main application Server applications: handling client connections concurrently in a threaded server

Python standard library threading module Any Python application using threads

thread = threading.Thread(target=function, args=(arg1, arg2))

thread = threading.Thread(target=..., args=(...))

thread: Thread object identifier, function: callable to execute, arg1, arg2: positional arguments passed to function

• thread.start()
• thread.join()
• daemon flag

• lambda as target: quick inline wrapper but obscures tracebacks
• kwargs instead of args: clearer for functions with named parameters
• functools.partial: pre-binds arguments but adds import overhead

Forgetting .start(): thread object is created but never runs, no error is raised → silent no-op bug. Passing function result as target (target=func() instead of target=func): the function is called immediately in the main thread and its return value is assigned as target → TypeError at thread start. Unhandled exceptions in thread: exceptions are silently swallowed and only surface via .join() or explicit checking → hard-to-debug failures.

threading.Thread vs concurrent.futures.ThreadPoolExecutor: manual thread management vs pooled thread reuse with Future objects. threading.Thread vs multiprocessing.Process: shared-memory threads vs isolated processes bypassing the GIL.

Coming from Java: expecting to subclass Thread or implement Runnable → Python's threading.Thread takes a target callable directly. Coming from C++: expecting the thread to start immediately on construction → Python requires an explicit .start() call after instantiation.

• threading.Thread

Do not use for CPU-bound work due to the GIL — prefer multiprocessing instead. Each thread consumes an OS resource; unbounded thread creation can exhaust file descriptors or memory. The thread does not begin executing until .start() is called; the constructor only creates the object.

Enables concurrent execution, improving responsiveness for I/O-bound tasks.

Like handing off a task to an assistant — you give them the instructions (target) and the materials (args), but they don't start working until you say 'go' (.start()).

If target is a method of an object, pass self.method.

Basic Thread -> Thread with daemon flag -> ThreadPoolExecutor -> ProcessPoolExecutor for CPU-bound tasks