Summary  
This chapter introduces how to create and manage threads using Python’s threading module, covering the thread lifecycle (creation, start, execution, join), the impact of the global interpreter lock, and the use of locks to synchronize shared data and prevent race conditions.

General domain of usage  
I/O-bound operations


Imagine a kitchen as your Python process: it's the environment where all the action happens. Inside this kitchen, chefs represent threads—each chef is a worker, carrying out specific tasks. The fridge and counter are like your shared memory (RAM), where all chefs can reach for ingredients or place finished dishes. This is how threads in Python share data—they all work in the same space and can access the same resources.

When you run multiple threads, it's like having a team of chefs in the same kitchen. If one chef is waiting for the oven (an I/O bound operation), another can chop vegetables or start a new dish. This is concurrency: tasks overlap in time, making the kitchen more efficient.

However, there's a special rule in Python called the Global Interpreter Lock, or GIL. Think of the GIL as the 'Master Knife'—only one chef can use it at any moment. Chefs must pass the knife between them quickly, so it looks like they're all working at once. In reality, only one chef is actively preparing food with the knife at any given time. This means threads take turns running Python code, even though they share the kitchen.

Let's tie this back to the threading code example. When you create two threads, it's like hiring two chefs. Each chef has a name, so you can tell who is doing what. The 'start' method signals both chefs to begin working, and 'join' waits for both to finish before you close the kitchen. If both chefs need the fridge at the same time, you use a lock—like a kitchen rule—to make sure they don't collide or spoil the ingredients. This way, your kitchen (process) stays organized, and your chefs (threads) can work together safely and efficiently.. In video use code samples with 11 code lines maximum and one sample at each slide.

Python's `threading` module provides a simple yet powerful way to create and manage threads, enabling you to run multiple operations concurrently within a single process. Threads are lightweight units of execution that share the same memory space, making them suitable for tasks such as I/O operations, waiting for external resources, or updating user interfaces. 

The lifecycle of a thread typically involves several stages:  
- Creation: a thread object is instantiated but not yet started;  
- Starting: the thread's `start()` method is called, moving it to the ready-to-run state;  
- Running: the thread executes its target function;  
- Termination: the thread finishes execution, either by completing its task or by encountering an unhandled exception.



Managing threads requires careful attention to **synchronization**, since threads share data and resources. Without proper synchronization, you may encounter **race conditions** or inconsistent state. The `threading` module offers primitives like `Lock`, `RLock`, and `Event` to help coordinate thread access to shared resources.

 

Here is a table presenting functions that will help you to create, manage, and synchronize threads effectively when working with concurrent tasks in Python.

Creates a new thread object; pass a target function and arguments.

Begins execution of the thread; runs the target function in a new thread. 

Waits for the thread to finish before continuing execution.

Adds a thread object to a list; used to collect multiple threads so they can be managed as a group.

Returns the currently executing thread object. 

Creates a lock object for synchronizing access to shared resources.

Creates a re-entrant lock, allowing the same thread to acquire it multiple times.

Creates an event object for signaling between threads.

Sets or gets the thread's name for easier identification


The following example demonstrates how you can create and start multiple threads using the `threading` module, allowing several tasks to run concurrently.

import threading
import time

def print_numbers(name):
    for i in range(1, 4):
        print(f"Thread {name}: {i}")
        time.sleep(0.5)

# Create thread objects
thread1 = threading.Thread(target=print_numbers, args=("A",))
thread2 = threading.Thread(target=print_numbers, args=("B",))

# Start the threads
thread1.start()
thread2.start()

# Wait for both threads to finish
thread1.join()
thread2.join()

print("Both threads have finished.")

 You define a function, `print_numbers`, that prints a sequence of numbers along with the thread name. When creating each thread, you pass arguments using the `args` parameter - here, each thread receives a different name ("A" or "B") so you can easily distinguish their outputs. By calling the `start()` method, both threads begin execution and run concurrently. The `time.sleep(0.5)` call inside the loop simulates a delay in execution, which allows the threads to interleave their outputs and makes it easy to see that both threads are running at the same time. The `join()` method is then used to wait for both threads to complete before moving on, ensuring that the main program does not finish prematurely. This approach allows tasks to run in parallel, making efficient use of waiting times and enabling concurrent execution within a single process.

Which of the following statements about thread synchronization in Python is correct?

A deep dive into advanced structural programming concepts in Python, focusing on robust file handling, error management, concurrency, asynchronous programming and testing.

Master Python's exception system for robust error handling and debugging.

Explore advanced techniques for file operations and resource management using context managers.

Compare and apply Python's multithreading and multiprocessing modules for concurrent programming.

Master asynchronous programming in Python using the asyncio library for scalable I/O-bound applications.

Explore how to write, organize, and run tests using Python's unittest and pytest frameworks.

Working with Threads