Concurrency control

Launch a background task to run in parallel with the main program.

When you need to perform a lengthy operation without blocking the main thread; when you want to utilize multiple CPU cores via multiprocessing; when implementing a worker pool.

Used in Python's threading and multiprocessing modules; also in concurrent.futures wrappers; typical in scripts that perform I/O-bound or CPU-bound tasks concurrently.

process.start()

... .start()

process: an instance of threading.Thread or multiprocessing.Process (or any object with a start method).

• thread = threading.Thread(target=func)
• process = multiprocessing.Process(target=func)
• thread.join()
• process.join()
• daemon = True

• Using thread.run() instead of start() (runs in current thread)
• using concurrent.futures.ThreadPoolExecutor.submit()

Calling start() more than once on the same thread/process; forgetting to join leading to zombie threads/processes; not setting target before start.

thread.run() executes target in the current thread; process.terminate() forcefully stops a process; thread.join() waits for completion.

Coming from Java: similar start() method but requires extending Thread class; in Python you pass a target function.

• thread creation
• process creation
• concurrent execution
• worker pattern

start() returns immediately; the new thread/process begins execution asynchronously; if the program exits before non-daemon threads finish, it will wait for them; daemon threads are killed on exit.

Enables concurrent execution, improving responsiveness and throughput for I/O-bound or parallelizable workloads.

Hit start to launch the worker.

Remember to call join() after start() to wait for completion, unless the thread/process is daemonized.

Use concurrent.futures.ThreadPoolExecutor or ProcessPoolExecutor for higher-level task submission.