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.

Pythons `threading`-modul erbjuder ett enkelt men kraftfullt sätt att skapa och hantera trådar, vilket möjliggör att flera operationer kan köras samtidigt inom en enda process. Trådar är lättviktiga exekveringsenheter som delar samma minnesutrymme, vilket gör dem lämpliga för uppgifter som I/O-operationer, väntan på externa resurser eller uppdatering av användargränssnitt.

En tråds livscykel omfattar vanligtvis flera steg:  
- Skapande: ett trådobjekt instansieras men har ännu inte startats;  
- Start: trådens `start()`-metod anropas, vilket flyttar den till redo-att-köras-läget;  
- Körning: tråden exekverar sin mål-funktion;  
- Terminering: tråden avslutar exekveringen, antingen genom att slutföra sin uppgift eller genom att stöta på ett ohanterat undantag.



Att hantera trådar kräver noggrann uppmärksamhet på **synkronisering**, eftersom trådar delar data och resurser. Utan korrekt synkronisering kan du stöta på **kapplöpningssituationer** eller inkonsekvent tillstånd. `threading`-modulen erbjuder primitiv som `Lock`, `RLock` och `Event` för att hjälpa till att samordna tråders åtkomst till delade resurser.

 

Här är en tabell som presenterar funktioner som hjälper dig att skapa, hantera och synkronisera trådar effektivt när du arbetar med samtidiga uppgifter i 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


Följande exempel visar hur du kan skapa och starta flera trådar med hjälp av `threading`-modulen, vilket möjliggör att flera uppgifter kan köras samtidigt.

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

Du definierar en funktion, `print_numbers`, som skriver ut en sekvens av siffror tillsammans med trådens namn. När du skapar varje tråd skickar du argument med hjälp av parametern `args` – här får varje tråd ett unikt namn ("A" eller "B") så att du enkelt kan särskilja deras utskrifter. Genom att anropa metoden `start()` påbörjar båda trådarna sin exekvering och körs samtidigt. Anropet `time.sleep(0.5)` inuti loopen simulerar en fördröjning i exekveringen, vilket gör att trådarnas utskrifter kan blandas och tydligt visar att båda trådarna körs parallellt. Metoden `join()` används sedan för att vänta på att båda trådarna ska avslutas innan programmet går vidare, vilket säkerställer att huvudprogrammet inte avslutas i förtid. Detta tillvägagångssätt möjliggör parallell körning av uppgifter, effektivt utnyttjande av väntetider och samtidiga exekveringar inom en och samma process.

Vilket av följande påståenden om trådsynkronisering i Python är korrekt?

Du kommer att förvärva praktiska färdigheter i Pythons moduler och importer för effektiv kodhantering. Behärska avancerade tekniker för felhantering för mer tillförlitliga applikationer, automatisera filoperationer med filhantering och lär dig robusta teststrategier med Pytest och Unittest för att säkerställa kodens integritet.

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.

Arbete med trådar