Parallelität und Nebenläufigkeit, Multithreading und Multiprocessing und Asyncio in Python

Parallelität und Nebenläufigkeit sind wichtige Konzepte in der Programmierung, die es ermöglichen, mehrere Aufgaben gleichzeitig auszuführen. Python bietet mehrere Werkzeuge und Bibliotheken, um parallele und nebenläufige Programme zu erstellen, einschließlich Multithreading, Multiprocessing und Asyncio. In diesem Artikel werden wir diese Konzepte detailliert erläutern und mit Beispielen veranschaulichen.

1. Multithreading

Multithreading ermöglicht es, mehrere Threads innerhalb eines Prozesses auszuführen. Threads teilen sich den gleichen Speicherraum und sind leichtgewichtig, aber Python hat eine Einschränkung namens Global Interpreter Lock (GIL), die die echte parallele Ausführung von Threads verhindert.

Beispiel:

import threading
import time

def arbeite(id):
    print(f"Thread {id} startet")
    time.sleep(2)
    print(f"Thread {id} endet")

threads = []
for i in range(3):
    thread = threading.Thread(target=arbeite, args=(i,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("Alle Threads sind abgeschlossen")

Ausgabe:

Thread 0 startet
Thread 1 startet
Thread 2 startet
Thread 0 endet
Thread 1 endet
Thread 2 endet
Alle Threads sind abgeschlossen

Erklärung:

• threading.Thread(target=arbeite, args=(i,)): Erstellt einen neuen Thread, der die Funktion arbeite mit dem Argument i ausführt.
• thread.start(): Startet den Thread.
• thread.join(): Wartet, bis der Thread beendet ist.

2. Multiprocessing

Multiprocessing ermöglicht es, mehrere Prozesse auszuführen, die jeweils ihren eigenen Speicherraum haben. Dies umgeht das GIL und ermöglicht echte parallele Ausführung, ist jedoch ressourcenintensiver als Multithreading.

Beispiel:

import multiprocessing
import time

def arbeite(id):
    print(f"Prozess {id} startet")
    time.sleep(2)
    print(f"Prozess {id} endet")

prozesse = []
for i in range(3):
    prozess = multiprocessing.Process(target=arbeite, args=(i,))
    prozesse.append(prozess)
    prozess.start()

for prozess in prozesse:
    prozess.join()

print("Alle Prozesse sind abgeschlossen")

Ausgabe:

Prozess 0 startet
Prozess 1 startet
Prozess 2 startet
Prozess 0 endet
Prozess 1 endet
Prozess 2 endet
Alle Prozesse sind abgeschlossen

Erklärung:

• multiprocessing.Process(target=arbeite, args=(i,)): Erstellt einen neuen Prozess, der die Funktion arbeite mit dem Argument i ausführt.
• prozess.start(): Startet den Prozess.
• prozess.join(): Wartet, bis der Prozess beendet ist.

3. Asyncio

Asyncio ermöglicht die nebenläufige Programmierung mithilfe von async/await-Syntax und Ereignisschleifen. Es ist besonders nützlich für I/O-gebundene Aufgaben und Netzwerkanwendungen.

Beispiel:

import asyncio

async def arbeite(id):
    print(f"Task {id} startet")
    await asyncio.sleep(2)
    print(f"Task {id} endet")

async def main():
    tasks = []
    for i in range(3):
        task = asyncio.create_task(arbeite(i))
        tasks.append(task)
    
    for task in tasks:
        await task

asyncio.run(main())

print("Alle Tasks sind abgeschlossen")

Ausgabe:

Task 0 startet
Task 1 startet
Task 2 startet
Task 0 endet
Task 1 endet
Task 2 endet
Alle Tasks sind abgeschlossen

Erklärung:

• async def arbeite(id): Definiert eine asynchrone Funktion.
• await asyncio.sleep(2): Wartet asynchron für 2 Sekunden.
• asyncio.create_task(arbeite(i)): Erstellt einen neuen Task für die asynchrone Funktion arbeite.
• await task: Wartet, bis der Task beendet ist.
• asyncio.run(main()): Führt die Hauptfunktion main in der Ereignisschleife aus.

Zusammenfassung

Parallelität und Nebenläufigkeit sind wichtige Konzepte, um mehrere Aufgaben gleichzeitig auszuführen und die Leistung von Programmen zu verbessern. Python bietet verschiedene Werkzeuge zur Implementierung dieser Konzepte:

• Multithreading: Für leichtgewichtige parallele Aufgaben, eingeschränkt durch das GIL.
• Multiprocessing: Für echte parallele Ausführung, umgeht das GIL, aber ressourcenintensiver.
• Asyncio: Für nebenläufige I/O-gebundene Aufgaben und Netzwerkanwendungen.

Durch das Verständnis und die Anwendung dieser Konzepte können Sie die Effizienz und Leistung Ihrer Python-Programme erheblich verbessern.