Concurrency

Offloads a specific task to a separate thread, allowing the main program to continue executing or to run multiple I/O-bound tasks simultaneously.

GUI application: running a long-running calculation in the background while keeping the UI responsive Network service: performing multiple independent network requests in parallel Event loop: polling a resource or waiting for an event without freezing the main loop

Standard Python applications, I/O-bound services, GUI applications using Tkinter or PyQt, scripts requiring simple parallelism.

threading.Thread(target=target_func, args=(arg,))

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

target: callable function reference, arg1: first argument to pass to the function (additional args follow)

• thread.start()
• thread.join()
• daemon=True
• queue.Queue for thread-safe communication

• Using concurrent.futures.ThreadPoolExecutor for higher-level management
• multiprocessing.Process for CPU-bound tasks

Passing the function call instead of the reference (e.g., target=func() instead of target=func), forgetting to call start(), ignoring the need for a tuple for single arguments (args=(x,) not args=(x)).

multiprocessing.Process: similar API but spawns separate processes for CPU-bound tasks, bypassing the GIL. asyncio.create_task: for cooperative concurrency on a single thread.

Coming from Java: Python threads are subject to the Global Interpreter Lock (GIL), so they do not achieve true parallelism for CPU-bound code. Coming from Go: Python threads are heavier than goroutines and require explicit start/join management.

• threading.Lock
• threading.RLock
• threading.Semaphore
• multiprocessing.Process

Due to the GIL, this pattern is effective for I/O-bound tasks but offers no performance gain for CPU-bound calculations. For single arguments, the comma in the tuple is mandatory to distinguish it from a grouped expression.

Allows a function to run concurrently in a separate thread, enabling concurrent I/O or parallel execution without blocking the main program.

Think of spawning a thread like hiring a temporary worker to handle a task while you continue overseeing the project.

Remember to handle exceptions within the target function, as unhandled exceptions in a thread can cause silent termination.

Learn to use concurrent.futures.ThreadPoolExecutor for managing a pool of threads and simplifying thread lifecycle management.