Summary
This chapter explains how to create and manage threads with Python’s threading module, covering thread lifecycle methods like start() and join(), and using locks to synchronize access to shared data.

General domain of usage
I/O-bound tasks


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 9 code lines maximum and one sample at each slide.

Het `threading`-module van Python biedt een eenvoudige maar krachtige manier om threads te creëren en te beheren, waardoor het mogelijk is om meerdere bewerkingen gelijktijdig binnen één enkel proces uit te voeren. Threads zijn lichte uitvoeringsunits die hetzelfde geheugen delen, waardoor ze geschikt zijn voor taken zoals I/O-bewerkingen, wachten op externe bronnen of het bijwerken van gebruikersinterfaces.

De levenscyclus van een thread omvat doorgaans verschillende fasen:  
- Creatie: een thread-object wordt aangemaakt maar nog niet gestart;  
- Starten: de `start()`-methode van de thread wordt aangeroepen, waardoor deze naar de gereed-om-te-starten status gaat;  
- Uitvoering: de thread voert zijn doel-functie uit;  
- Beëindiging: de thread voltooit de uitvoering, hetzij door de taak af te ronden, hetzij door een niet-afgehandelde uitzondering.



Het beheren van threads vereist zorgvuldige aandacht voor **synchronisatie**, omdat threads gegevens en bronnen delen. Zonder juiste synchronisatie kunnen **racecondities** of een inconsistente toestand optreden. Het `threading`-module biedt hulpmiddelen zoals `Lock`, `RLock` en `Event` om de toegang van threads tot gedeelde bronnen te coördineren.

 

Hieronder staat een tabel met functies die helpen bij het effectief creëren, beheren en synchroniseren van threads bij het werken met gelijktijdige taken 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


Het volgende voorbeeld laat zien hoe je meerdere threads kunt creëren en starten met behulp van het `threading`-module, zodat verschillende taken gelijktijdig kunnen worden uitgevoerd.

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.")

Je definieert een functie, `print_numbers`, die een reeks getallen samen met de threadnaam afdrukt. Bij het aanmaken van elke thread geef je argumenten door via de parameter `args` – hier krijgt elke thread een andere naam ("A" of "B"), zodat je hun uitvoer eenvoudig kunt onderscheiden. Door de methode `start()` aan te roepen, beginnen beide threads met uitvoeren en lopen ze gelijktijdig. De aanroep `time.sleep(0.5)` binnen de lus simuleert een vertraging in de uitvoering, waardoor de uitvoer van de threads door elkaar kan lopen en het duidelijk wordt dat beide threads tegelijkertijd actief zijn. De methode `join()` wordt vervolgens gebruikt om te wachten tot beide threads klaar zijn voordat het programma verdergaat, zodat het hoofdprogramma niet voortijdig eindigt. Deze aanpak maakt het mogelijk om taken parallel uit te voeren, waardoor wachttijden efficiënt worden benut en gelijktijdige uitvoering binnen één proces mogelijk is.

Welke van de volgende uitspraken over thread-synchronisatie in Python is correct?

Je verwerft praktische vaardigheden in het gebruik van Python-modules en imports voor efficiënt codebeheer. Beheers geavanceerde foutafhandelings­technieken voor betrouwbaardere applicaties, automatiseer bestandsbewerkingen met bestandsafhandeling en leer robuuste teststrategieën met Pytest en Unittest om de integriteit van je code te waarborgen.

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.

Werken met Threads