Python Multithreading und Multiprocessing

Einführung

Betreten Sie eine Welt, in der die industrielle Revolution die Gesellschaft umgestaltet hat, und der Hektik des Lebens im viktorianischen Zeitalter des 19. Jahrhunderts prägt die Pflasterstraßen. Hier, inmitten der nebligen Gassen, die vom Klappern von Pferdekutschen und dem entfernten Summen von Fabrikmaschinen durchzogen sind, lebt eine Figur, deren Talent die gedrängten Menschenmassen fasziniert – ein Straßenkünstler, der für seine unglaubliche Fähigkeit bekannt ist, mehrere Aufgaben gleichzeitig zu bewältigen.

Unser Künstler, Oliver genannt, ist berühmt dafür, Gegenstände zu jonglieren, während er auf einem Einrad balanciert, die Mundharmonika spielt und gleichzeitig komplexe Rätsel löst. Zu der Verwunderung seiner Zuschauer sind Olivers Leistungen nahtlos und effizient, ein Zeugnis seiner Beherrschung von parallelen Aktivitäten. Dieses Lab zielt darauf ab, Olivers Fähigkeiten bei der Verarbeitung mehrerer Aufgaben gleichzeitig zu widerspiegeln, indem es die Multithreading- und Multiprocessing-Fähigkeiten von Python untersucht, um sicherzustellen, dass Programmierer mehrere Aufgaben gleichzeitig problemlos verwalten können.

Das Verständnis von Threads

In diesem Schritt lernen Sie die Grundlagen des Threadings in Python. Threading ermöglicht es Ihnen, mehrere Operationen gleichzeitig auszuführen, was so aussieht, als würde Ihr Programm gleichzeitig mehr als eine Sache tun, genau wie Olivers Fähigkeit, während des Fahrradfahrens zu jonglieren.

Öffnen Sie in Ihrem Projektverzeichnis ~/project eine Datei namens simple_threads.py mit dem folgenden Inhalt:

import threading
import time

def print_numbers():
    for i in range(1, 6):
        time.sleep(1)
        print(i)

## Create two threads
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_numbers)

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

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

print("Done with numbers!")

Führen Sie den obigen Code im Terminal mit folgendem Befehl aus:

python simple_threads.py

Sie sollten sehen, dass die Zahlen von beiden Threads gemischt ausgegeben werden, gefolgt von "Done with numbers!":

1
1
2
2
3
3
4
4
5
5
Done with numbers!

Die Nutzung von Multiprocessing

Lassen Sie uns nun Multiprocessing verwenden, um die Rechenleistung zu beschleunigen. Multiprocessing in Python ermöglicht die Ausführung mehrerer Prozesse, die auf verschiedenen CPU-Kernen laufen können, was die Gesamtzeit für rechenintensive Aufgaben reduziert.

Öffnen Sie in Ihrem Projektverzeichnis ~/project eine Datei namens process_prime.py mit dem folgenden Inhalt:

from multiprocessing import Process
import math

def is_prime(num):
    """
    Überprüft, ob eine Zahl eine Primzahl ist.
    """
    if num <= 1:
        return False
    for i in range(2, int(math.sqrt(num)) + 1):
        if num % i == 0:
            return False
    return True

def compute_primes(start, end):
    """
    Berechnet Primzahlen innerhalb eines angegebenen Bereichs.
    """
    prime_numbers = [num for num in range(start, end) if is_prime(num)]
    print(f"Primzahlen im Bereich {start}-{end}: {prime_numbers}")

processes = []
## Erstellen von zwei Prozessen
for i in range(0, 20000, 10000):
    ## Erstellen eines neuen Prozesses, der die compute_primes-Funktion aufruft und den Bereich als Argumente übergibt
    p = Process(target=compute_primes, args=(i, i+10000))
    processes.append(p)
    ## Starten des Prozesses
    p.start()

## Warten auf das Ende aller Prozesse
for p in processes:
    p.join()

print("Fertig mit der Primzahlberechnung!")

Führen Sie das Skript im Terminal aus:

python process_prime.py

Dies wird die gefundenen Primzahlen im angegebenen Bereich ausgeben und eine Abschlussmeldung anzeigen:

Primzahlen im Bereich 0-10000: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241,
......
9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973]
Primzahlen im Bereich 10000-20000: [10007, 10009, 10037, 10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 10103, 10111, 10133, 10139, 10141, 10151, 10159, 10163, 10169, 10177, 10181, 10193,
......
19739, 19751, 19753, 19759, 19763, 19777, 19793, 19801, 19813, 19819, 19841, 19843, 19853, 19861, 19867, 19889, 19891, 19913, 19919, 19927, 19937, 19949, 19961, 19963, 19973, 19979, 19991, 19993, 19997]
Fertig mit der Primzahlberechnung!

Zusammenfassung

In diesem Lab haben wir eine spannende Reise unternommen, um die Feinheiten von Threading und Multiprocessing in Python zu entpacken, ähnlich den mehrschichtigen Performances von viktorianischen Straßenkünstlern. Wir haben begonnen, Aufgaben mit Threads zu jonglieren und sind dann zu der Verarbeitung umfangreicher Operationen über die CPU-Kerne aufgestiegen. Diese Übung hat nicht nur die parallelen Fähigkeiten von Python gezeigt, sondern hat auch gezeigt, wie diese Techniken eine reale Bedeutung in der Welt haben, ähnlich den facettenreichen Darstellungen von Können durch unseren Charakter Oliver.

Ihr Fazit aus diesem Lab sollte eine klare Vorstellung von Python-Threads für I/O-beschränkte Aufgaben und Prozessen für rechenintensive Aufgaben umfassen, was Ihre Codierleistung effektiv erhöht und Ihre Anwendungen effizienter macht.