einer der am meisten erwarteten Veröffentlichungen der letzten Zeit, ist endlich da. Der Grund dafür ist, dass in dieser Model mehrere spannende Verbesserungen implementiert wurden, darunter:
Unterdolmetscher. Diese sind seit 20 Jahren in Python verfügbar, aber um sie nutzen zu können, musste man auf die Codierung in C umsteigen. Jetzt können sie direkt aus Python selbst verwendet werden.
T-Strings. Vorlagenzeichenfolgen sind eine neue Methode zur benutzerdefinierten Zeichenfolgenverarbeitung. Sie verwenden die bekannte Syntax von F-Strings, geben aber im Gegensatz zu F-Strings ein Objekt zurück, das sowohl den statischen als auch den interpolierten Teil des Strings darstellt, und nicht einen einfachen String.
Ein Simply-in-Time-Compiler. Dies ist noch eine experimentelle Funktion und sollte nicht in Produktionssystemen verwendet werden. Es verspricht jedoch eine Leistungssteigerung für bestimmte Anwendungsfälle.
Es gibt viele weitere Verbesserungen in Python 3.14, aber in diesem Artikel geht es nicht um diese oder die oben erwähnten.
Stattdessen werden wir die wahrscheinlich am meisten erwartete Funktion dieser Model besprechen: Free-Threaded-Python, auch bekannt als GIL-freies Python. Beachten Sie, dass normales Python 3.14 weiterhin mit aktivierter GIL läuft, Sie können jedoch eine separate Free-Thread-Model herunterladen (oder erstellen). Ich zeige Ihnen, wie Sie es herunterladen und installieren, und demonstriere anhand mehrerer Codierungsbeispiele einen Vergleich der Laufzeiten zwischen regulärem und GIL-freiem Python 3.14.
Was ist die GIL?
Viele von Ihnen werden den World Interpreter Lock (GIL) in Python kennen. Die GIL ist ein Mutex – ein Sperrmechanismus – der zum Synchronisieren des Zugriffs auf Ressourcen verwendet wird und in Python sicherstellt, dass jeweils nur ein Thread Bytecode ausführt.
Dies hat einerseits mehrere Vorteile, darunter die einfachere Thread- und Speicherverwaltung, die Vermeidung von Race Circumstances und die Integration von Python in C/C++-Bibliotheken.
Andererseits kann die GIL die Parallelität unterdrücken. Mit der GIL ist keine echte Parallelität für CPU-gebundene Aufgaben über mehrere CPU-Kerne innerhalb eines einzelnen Python-Prozesses möglich.
Warum das wichtig ist
Mit einem Wort, „Leistung“.
Da bei der Free-Thread-Ausführung alle verfügbaren Kerne Ihres Methods gleichzeitig genutzt werden können, wird Code oft schneller ausgeführt. Als Datenwissenschaftler und ML oder Dateningenieure gilt dies nicht nur für Ihren Code, sondern auch für den Code, der die Systeme, Frameworks und Bibliotheken erstellt, auf die Sie sich verlassen.
Viele Aufgaben des maschinellen Lernens und der Datenwissenschaft sind rechenintensiv, insbesondere während des Modelltrainings und der Datenvorverarbeitung. Die Entfernung der GIL könnte zu erheblichen Leistungsverbesserungen für diese CPU-gebundenen Aufgaben führen.
Viele beliebte Bibliotheken in Python sind mit Einschränkungen konfrontiert, weil sie die GIL umgehen mussten. Seine Entfernung könnte zu Folgendem führen:
- Vereinfachte und möglicherweise effizientere Implementierungen dieser Bibliotheken
- Neue Optimierungsmöglichkeiten in bestehenden Bibliotheken
- Entwicklung neuer Bibliotheken, die die Vorteile der Parallelverarbeitung voll ausnutzen können
Set up der Free-Threaded-Python-Model
Wenn Sie ein Linux-Benutzer sind, besteht die einzige Möglichkeit, Python mit kostenlosem Threading zu erhalten, darin, es selbst zu erstellen. Wenn Sie wie ich Home windows (oder macOS) verwenden, können Sie es mit den offiziellen Installationsprogrammen von der Python-Web site installieren. Während des Vorgangs haben Sie die Möglichkeit, Ihre Set up anzupassen. Suchen Sie nach einem Kontrollkästchen, um die Free-Thread-Binärdateien einzuschließen. Dadurch wird ein separater Interpreter installiert, mit dem Sie Ihren Code ohne die GIL ausführen können. Ich zeige, wie die Set up auf einem 64-Bit-Home windows-System funktioniert.
Klicken Sie zunächst auf die folgende URL:
https://www.python.org/downloads/launch/python-3140
Scrollen Sie nach unten, bis Sie eine Tabelle sehen, die so aussieht.
Klicken Sie nun auf den Hyperlink Home windows Installer (64-Bit). Sobald die ausführbare Datei heruntergeladen wurde, öffnen Sie sie und klicken Sie im ersten angezeigten Installationsbildschirm auf Passen Sie die Set up an Hyperlink. Beachten Sie, dass ich das auch überprüft habe Fügen Sie Python.exe zum Pfad hinzu Kontrollkästchen.
Wählen Sie im nächsten Bildschirm die optionalen Extras aus, die Sie zur Set up hinzufügen möchten, und klicken Sie dann auf Nächste wieder. An diesem Punkt sollten Sie einen Bildschirm wie diesen sehen:
Stellen Sie sicher, dass das Kontrollkästchen daneben aktiviert ist Laden Sie kostenlose Binärdateien herunter ausgewählt ist. Ich habe das auch überprüft Installieren Sie Python 3.14 für alle Benutzer Choice.
Klicken Sie auf die Schaltfläche „Installieren“.
Suchen Sie nach Abschluss des Downloads im Installationsordner nach einer Python-Anwendungsdatei mit einem „t“ am Ende des Namens. Dies ist die GIL-freie Model von Python. Die Anwendungsdatei namens Python ist die reguläre ausführbare Python-Datei. In meinem Fall hieß das GIL-freie Python Python3.14t. Sie können überprüfen, ob es korrekt installiert wurde, indem Sie dies in eine Befehlszeile eingeben.
C:Usersthoma>python3.14t
Python 3.14.0 free-threading construct (tags/v3.14.0:ebf955d, Oct 7 2025, 10:13:09) (MSC v.1944 64 bit (AMD64)) on win32
Sort "assist", "copyright", "credit" or "license" for extra data.
>>> Wenn Sie das sehen, sind Sie startklar. Überprüfen Sie andernfalls, ob der Installationsort zu Ihrer PATH-Umgebungsvariablen hinzugefügt wurde und/oder überprüfen Sie Ihre Installationsschritte noch einmal.
Da wir die GIL-freien Python-Laufzeiten mit den regulären Python-Laufzeiten vergleichen, sollten wir auch überprüfen, ob diese auch korrekt installiert sind.
C:Usersthoma>python
Python 3.14.0 (tags/v3.14.0:ebf955d, Oct 7 2025, 10:15:03) (MSC v.1944 64 bit (AMD64)) on win32
Sort "assist", "copyright", "credit" or "license" for extra data.
>>>GIL vs. GIL-freies Python
Beispiel 1 – Primzahlen finden
Geben Sie Folgendes in eine Python-Codedatei ein, z. B. example1.py
#
# example1.py
#
import threading
import time
import multiprocessing
def is_prime(n):
"""Verify if a quantity is prime."""
if n < 2:
return False
for i in vary(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
def find_primes(begin, finish):
"""Discover all prime numbers within the given vary."""
primes = ()
for num in vary(begin, finish + 1):
if is_prime(num):
primes.append(num)
return primes
def employee(worker_id, begin, finish):
"""Employee perform to search out primes in a selected vary."""
print(f"Employee {worker_id} beginning")
primes = find_primes(begin, finish)
print(f"Employee {worker_id} discovered {len(primes)} primes")
def foremost():
"""Most important perform to coordinate the multi-threaded prime search."""
start_time = time.time()
# Get the variety of CPU cores
num_cores = multiprocessing.cpu_count()
print(f"Variety of CPU cores: {num_cores}")
# Outline the vary for prime search
total_range = 2_000_000
chunk_size = total_range // num_cores
threads = ()
# Create and begin threads equal to the variety of cores
for i in vary(num_cores):
begin = i * chunk_size + 1
finish = (i + 1) * chunk_size if i < num_cores - 1 else total_range
thread = threading.Thread(goal=employee, args=(i, begin, finish))
threads.append(thread)
thread.begin()
# Anticipate all threads to finish
for thread in threads:
thread.be part of()
# Calculate and print the overall execution time
end_time = time.time()
total_time = end_time - start_time
print(f"All staff accomplished in {total_time:.2f} seconds")
if __name__ == "__main__":
foremost()Der is_prime Funktion prüft, ob eine gegebene Zahl eine Primzahl ist.
Der find_primes Die Funktion findet alle Primzahlen innerhalb eines bestimmten Bereichs.
Der Arbeitnehmer Die Funktion ist das Ziel für jeden Thread und findet Primzahlen in einem bestimmten Bereich.
Der hauptsächlich Funktion koordiniert die Multithread-Primärsuche:
- Es unterteilt den Gesamtbereich in die Anzahl der Blöcke, die der Anzahl der Kerne des Methods entspricht (in meinem Fall 32).
- Erstellt und startet 32 Threads, wobei jeder einen kleinen Teil des Bereichs durchsucht.
- Wartet, bis alle Threads abgeschlossen sind.
- Berechnet die Gesamtausführungszeit und druckt sie aus.
Timing-Ergebnisse
Mal sehen, wie lange die Ausführung mit normalem Python dauert.
C:Usersthomaprojectspython-gil>python example1.py
Variety of CPU cores: 32
Employee 0 beginning
Employee 1 beginning
Employee 0 discovered 6275 primes
Employee 2 beginning
Employee 3 beginning
Employee 1 discovered 5459 primes
Employee 4 beginning
Employee 2 discovered 5230 primes
Employee 3 discovered 5080 primes
...
...
Employee 27 discovered 4346 primes
Employee 15 beginning
Employee 22 discovered 4439 primes
Employee 30 discovered 4338 primes
Employee 28 discovered 4338 primes
Employee 31 discovered 4304 primes
Employee 11 discovered 4612 primes
Employee 15 discovered 4492 primes
Employee 25 discovered 4346 primes
Employee 26 discovered 4377 primes
All staff accomplished in 3.70 secondsJetzt mit der GIL-freien Model:
C:Usersthomaprojectspython-gil>python3.14t example1.py
Variety of CPU cores: 32
Employee 0 beginning
Employee 1 beginning
Employee 2 beginning
Employee 3 beginning
...
...
Employee 19 discovered 4430 primes
Employee 29 discovered 4345 primes
Employee 30 discovered 4338 primes
Employee 18 discovered 4520 primes
Employee 26 discovered 4377 primes
Employee 27 discovered 4346 primes
Employee 22 discovered 4439 primes
Employee 23 discovered 4403 primes
Employee 31 discovered 4304 primes
Employee 28 discovered 4338 primes
All staff accomplished in 0.35 secondsDas ist ein beeindruckender Anfang. Eine 10-fache Verbesserung der Laufzeit.
Beispiel 2 – Mehrere Dateien gleichzeitig lesen.
In diesem Beispiel verwenden wir das Modell concurrent.futures, um mehrere Textdateien gleichzeitig zu lesen und die Anzahl der Zeilen und Wörter in jeder Datei zu zählen und anzuzeigen.
Bevor wir das tun, müssen wir einige Datendateien verarbeiten. Sie können dazu den folgenden Python-Code verwenden. Es generiert jeweils 1.000.000 zufällige, unsinnige Sätze und schreibt sie in 20 separate Textdateien, Sätze_01.txt, Sätze_02.txt usw.
import os
import random
import time
# --- Configuration ---
NUM_FILES = 20
SENTENCES_PER_FILE = 1_000_000
WORDS_PER_SENTENCE_MIN = 8
WORDS_PER_SENTENCE_MAX = 20
OUTPUT_DIR = "fake_sentences" # Listing to save lots of the information
# --- 1. Generate a pool of phrases ---
# Utilizing a small checklist of frequent phrases for selection.
# In an actual state of affairs, you may load a a lot bigger dictionary.
word_pool = (
"the", "be", "to", "of", "and", "a", "in", "that", "have", "i",
"it", "for", "not", "on", "with", "he", "as", "you", "do", "at",
"this", "however", "his", "by", "from", "they", "we", "say", "her", "she",
"or", "an", "will", "my", "one", "all", "would", "there", "their", "what",
"so", "up", "out", "if", "about", "who", "get", "which", "go", "me",
"when", "make", "can", "like", "time", "no", "simply", "him", "know", "take",
"individuals", "into", "yr", "your", "good", "some", "might", "them", "see", "different",
"than", "then", "now", "look", "solely", "come", "its", "over", "suppose", "additionally",
"again", "after", "use", "two", "how", "our", "work", "first", "nicely", "manner",
"even", "new", "need", "as a result of", "any", "these", "give", "day", "most", "us",
"apple", "banana", "automotive", "home", "pc", "cellphone", "espresso", "water", "sky", "tree",
"comfortable", "unhappy", "huge", "small", "quick", "sluggish", "pink", "blue", "inexperienced", "yellow"
)
# Guarantee output listing exists
os.makedirs(OUTPUT_DIR, exist_ok=True)
print(f"Beginning to generate {NUM_FILES} information, every with {SENTENCES_PER_FILE:,} sentences.")
print(f"Complete sentences to generate: {NUM_FILES * SENTENCES_PER_FILE:,}")
start_time = time.time()
for file_idx in vary(NUM_FILES):
file_name = os.path.be part of(OUTPUT_DIR, f"sentences_{file_idx + 1:02d}.txt")
print(f"nGenerating and writing to {file_name}...")
file_start_time = time.time()
with open(file_name, 'w', encoding='utf-8') as f:
for sentence_idx in vary(SENTENCES_PER_FILE):
# 2. Assemble faux sentences
num_words = random.randint(WORDS_PER_SENTENCE_MIN, WORDS_PER_SENTENCE_MAX)
# Randomly choose phrases
sentence_words = random.selections(word_pool, ok=num_words)
# Be a part of phrases, capitalize first, add a interval
sentence = " ".be part of(sentence_words).capitalize() + ".n"
# 3. Write to file
f.write(sentence)
# Optionally available: Print progress for big information
if (sentence_idx + 1) % 100_000 == 0:
print(f" {sentence_idx + 1:,} sentences written to {file_name}...")
file_end_time = time.time()
print(f"Completed {file_name} in {file_end_time - file_start_time:.2f} seconds.")
total_end_time = time.time()
print(f"nAll information generated! Complete time: {total_end_time - start_time:.2f} seconds.")
print(f"Recordsdata saved within the '{OUTPUT_DIR}' listing.")So sieht der Anfang von Sätzen_01.txt aus:
New then espresso have who banana his their how yr additionally there i take.
Cellphone go or with over who one at cellphone there on will.
With or how my us him our unhappy as do be take nicely manner with inexperienced small these.
Not from the 2 that so good sluggish new.
See look water me do new work new into on which be tree how an would out unhappy.
By be into then work into we they sky sluggish that each one who additionally.
Come use would have again from as after in again he give there pink additionally first see.
Solely come so nicely huge into some my into time its banana for come or what work.
How solely espresso out approach to simply tree when by there for pc work individuals sky by this into.
Than say out on it how she apple pc us nicely then sky sky day by different after not.
You content know a sluggish for for comfortable then additionally with apple suppose look go when.
As who for than two we up any can banana at.
Espresso a up of up these inexperienced small this us give we.
These we do as a result of how know me pc banana again cellphone manner time in what.OK, jetzt können wir messen, wie lange es dauert, diese Dateien zu lesen. Hier ist der Code, den wir testen werden. Es liest einfach jede Datei, zählt die Zeilen und Wörter und gibt die Ergebnisse aus.
import concurrent.futures
import os
import time
def process_file(filename):
"""
Course of a single file, returning its line depend and phrase depend.
"""
strive:
with open(filename, 'r') as file:
content material = file.learn()
strains = content material.break up('n')
phrases = content material.break up()
return filename, len(strains), len(phrases)
besides Exception as e:
return filename, -1, -1 # Return -1 for each counts if there's an error
def foremost():
start_time = time.time() # Begin the timer
# Checklist to carry our information
information = (f"./knowledge/sentences_{i:02d}.txt" for i in vary(1, 21)) # Assumes 20 information named file_1.txt to file_20.txt
# Use a ThreadPoolExecutor to course of information in parallel
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
# Submit all file processing duties
future_to_file = {executor.submit(process_file, file): file for file in information}
# Course of outcomes as they full
for future in concurrent.futures.as_completed(future_to_file):
file = future_to_file(future)
strive:
filename, line_count, word_count = future.consequence()
if line_count == -1:
print(f"Error processing {filename}")
else:
print(f"{filename}: {line_count} strains, {word_count} phrases")
besides Exception as exc:
print(f'{file} generated an exception: {exc}')
end_time = time.time() # Finish the timer
print(f"Complete execution time: {end_time - start_time:.2f} seconds")
if __name__ == "__main__":
foremost()Timing-Ergebnisse
Zuerst normales Python.
C:Usersthomaprojectspython-gil>python example2.py
./knowledge/sentences_09.txt: 1000001 strains, 14003319 phrases
./knowledge/sentences_01.txt: 1000001 strains, 13999989 phrases
./knowledge/sentences_05.txt: 1000001 strains, 13998447 phrases
./knowledge/sentences_07.txt: 1000001 strains, 14004961 phrases
./knowledge/sentences_02.txt: 1000001 strains, 14009745 phrases
./knowledge/sentences_10.txt: 1000001 strains, 14000166 phrases
./knowledge/sentences_06.txt: 1000001 strains, 13995223 phrases
./knowledge/sentences_04.txt: 1000001 strains, 14005683 phrases
./knowledge/sentences_03.txt: 1000001 strains, 14004290 phrases
./knowledge/sentences_12.txt: 1000001 strains, 13997193 phrases
./knowledge/sentences_08.txt: 1000001 strains, 13995506 phrases
./knowledge/sentences_15.txt: 1000001 strains, 13998555 phrases
./knowledge/sentences_11.txt: 1000001 strains, 14001299 phrases
./knowledge/sentences_14.txt: 1000001 strains, 13998347 phrases
./knowledge/sentences_13.txt: 1000001 strains, 13998035 phrases
./knowledge/sentences_19.txt: 1000001 strains, 13999642 phrases
./knowledge/sentences_20.txt: 1000001 strains, 14001696 phrases
./knowledge/sentences_17.txt: 1000001 strains, 14000184 phrases
./knowledge/sentences_18.txt: 1000001 strains, 13999968 phrases
./knowledge/sentences_16.txt: 1000001 strains, 14000771 phrases
Complete execution time: 18.77 secondsNun zur GIL-freien Model
C:Usersthomaprojectspython-gil>python3.14t example2.py
./knowledge/sentences_02.txt: 1000001 strains, 14009745 phrases
./knowledge/sentences_03.txt: 1000001 strains, 14004290 phrases
./knowledge/sentences_08.txt: 1000001 strains, 13995506 phrases
./knowledge/sentences_07.txt: 1000001 strains, 14004961 phrases
./knowledge/sentences_04.txt: 1000001 strains, 14005683 phrases
./knowledge/sentences_05.txt: 1000001 strains, 13998447 phrases
./knowledge/sentences_01.txt: 1000001 strains, 13999989 phrases
./knowledge/sentences_10.txt: 1000001 strains, 14000166 phrases
./knowledge/sentences_06.txt: 1000001 strains, 13995223 phrases
./knowledge/sentences_09.txt: 1000001 strains, 14003319 phrases
./knowledge/sentences_12.txt: 1000001 strains, 13997193 phrases
./knowledge/sentences_11.txt: 1000001 strains, 14001299 phrases
./knowledge/sentences_18.txt: 1000001 strains, 13999968 phrases
./knowledge/sentences_14.txt: 1000001 strains, 13998347 phrases
./knowledge/sentences_13.txt: 1000001 strains, 13998035 phrases
./knowledge/sentences_16.txt: 1000001 strains, 14000771 phrases
./knowledge/sentences_19.txt: 1000001 strains, 13999642 phrases
./knowledge/sentences_15.txt: 1000001 strains, 13998555 phrases
./knowledge/sentences_17.txt: 1000001 strains, 14000184 phrases
./knowledge/sentences_20.txt: 1000001 strains, 14001696 phrases
Complete execution time: 5.13 secondsNicht ganz so beeindruckend wie unser erstes Beispiel, aber immer noch sehr intestine und zeigt eine mehr als dreifache Verbesserung.
Beispiel 3 – Matrixmultiplikation
Wir werden das verwenden Einfädeln Modul dafür. Hier ist der Code, den wir ausführen werden.
import threading
import time
import os
def multiply_matrices(A, B, consequence, start_row, end_row):
"""Multiply a submatrix of A and B and retailer the consequence within the corresponding submatrix of consequence."""
for i in vary(start_row, end_row):
for j in vary(len(B(0))):
sum_val = 0
for ok in vary(len(B)):
sum_val += A(i)(ok) * B(ok)(j)
consequence(i)(j) = sum_val
def foremost():
"""Most important perform to coordinate the multi-threaded matrix multiplication."""
start_time = time.time()
# Outline the scale of the matrices
measurement = 1000
A = ((1 for _ in vary(measurement)) for _ in vary(measurement))
B = ((1 for _ in vary(measurement)) for _ in vary(measurement))
consequence = ((0 for _ in vary(measurement)) for _ in vary(measurement))
# Get the variety of CPU cores to determine on the variety of threads
num_threads = os.cpu_count()
print(f"Variety of CPU cores: {num_threads}")
chunk_size = measurement // num_threads
threads = ()
# Create and begin threads
for i in vary(num_threads):
start_row = i * chunk_size
end_row = measurement if i == num_threads - 1 else (i + 1) * chunk_size
thread = threading.Thread(goal=multiply_matrices, args=(A, B, consequence, start_row, end_row))
threads.append(thread)
thread.begin()
# Anticipate all threads to finish
for thread in threads:
thread.be part of()
end_time = time.time()
# Simply print a small nook to confirm
print("High-left 5x5 nook of the consequence matrix:")
for r_idx in vary(5):
print(consequence(r_idx)(:5))
print(f"Complete execution time (matrix multiplication): {end_time - start_time:.2f} seconds")
if __name__ == "__main__":
foremost()Der Code führt eine Matrixmultiplikation von zwei 1000×1000-Matrizen parallel unter Verwendung mehrerer CPU-Kerne durch. Es unterteilt die Ergebnismatrix in Blöcke, weist jeden Block einem separaten Prozess zu (entspricht der Anzahl der CPU-Kerne) und jeder Prozess berechnet seinen zugewiesenen Teil der Matrixmultiplikation unabhängig. Schließlich wartet es darauf, dass alle Prozesse abgeschlossen sind, und meldet die Gesamtausführungszeit. So wird demonstriert, wie Multiprocessing genutzt werden kann, um CPU-gebundene Aufgaben zu beschleunigen.
Timing-Ergebnisse
Reguläres Python:
C:Usersthomaprojectspython-gil>python example3.py
Variety of CPU cores: 32
High-left 5x5 nook of the consequence matrix:
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
Complete execution time (matrix multiplication): 43.95 secondsGIL-freies Python:
C:Usersthomaprojectspython-gil>python3.14t example3.py
Variety of CPU cores: 32
High-left 5x5 nook of the consequence matrix:
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
Complete execution time (matrix multiplication): 4.56 secondsMit GIL-freiem Python erzielen wir erneut eine quick zehnfache Verbesserung. Nicht zu schäbig.
GIL-frei ist nicht immer besser.
Ein interessanter Punkt ist, dass ich es bei diesem letzten Take a look at auch mit einer Multiprozessorversion des Codes versucht habe. Es stellte sich heraus, dass das reguläre Python deutlich schneller (28 %) battle als das GIL-freie Python. Ich werde nicht den Code präsentieren, sondern nur die Ergebnisse.
Zeitangaben
Zuerst normales Python (Multiprocessing).
C:Usersthomaprojectspython-gil>python example4.py
Variety of CPU cores: 32
High-left 5x5 nook of the consequence matrix:
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
Complete execution time (matrix multiplication): 4.49 secondsGIL-freie Model (Multiprocessing)
C:Usersthomaprojectspython-gil>python3.14t example4.py
Variety of CPU cores: 32
High-left 5x5 nook of the consequence matrix:
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
(1000, 1000, 1000, 1000, 1000)
Complete execution time (matrix multiplication): 6.29 secondsWie immer in solchen Situationen ist es wichtig, gründlich zu testen.
Denken Sie daran, dass diese letzten Beispiele sind gerecht Exams, um den Unterschied zwischen GIL und GIL-freiem Python aufzuzeigen. Die Verwendung einer externen Bibliothek wie NumPy zur Durchführung der Matrixmultiplikation wäre mindestens eine Größenordnung schneller als beides.
Ein weiterer Punkt, den Sie beachten sollten, wenn Sie sich für die Verwendung von Free-Threading-Python in Ihren Workloads entscheiden, ist, dass nicht alle Bibliotheken von Drittanbietern, die Sie möglicherweise verwenden möchten, damit kompatibel sind. Die Liste der inkompatiblen Bibliotheken ist klein und wird mit jeder Veröffentlichung kleiner, aber Sie sollten dies im Hinterkopf behalten. Um eine Liste davon anzuzeigen, klicken Sie bitte auf den untenstehenden Hyperlink.
Zusammenfassung
In diesem Artikel besprechen wir eine möglicherweise bahnbrechende Funktion der neuesten Model von Python 3.14: die Einführung einer optionalen „Free-Threaded“-Model, die die World Interpreter Lock (GIL) entfernt. Die GIL ist ein Mechanismus in Normal-Python, der die Speicherverwaltung vereinfacht, indem er sicherstellt, dass jeweils nur ein Thread Python-Bytecode ausführt. Dies kann zwar in manchen Fällen nützlich sein, verhindert jedoch eine echte Parallelverarbeitung auf Multi-Core-CPUs für CPU-intensive Aufgaben.
Die Entfernung der GIL im Free-Threaded-Construct dient in erster Linie der Verbesserung Leistung. Dies kann besonders für Datenwissenschaftler und Ingenieure für maschinelles Lernen nützlich sein, deren Arbeit häufig CPU-gebundene Vorgänge wie Modelltraining und Datenvorverarbeitung umfasst. Diese Änderung ermöglicht es Python-Code, alle verfügbaren CPU-Kerne gleichzeitig in einem einzigen Prozess zu nutzen, was möglicherweise zu erheblichen Geschwindigkeitsverbesserungen führt.
Um die Auswirkungen zu veranschaulichen, werden in dem Artikel mehrere Leistungsvergleiche vorgestellt:
- Primzahlen finden: Ein Multithread-Skript sah dramatisch aus 10-fache Leistungssteigerungwobei die Ausführungszeit von 3,70 Sekunden im Normal-Python auf nur 0,35 Sekunden in der GIL-freien Model sank.
- Mehrere Dateien gleichzeitig lesen: Eine E/A-gebundene Aufgabe, die einen Thread-Pool zur Verarbeitung von 20 großen Textdateien nutzte, battle beendet 3-mal schnellerund dauerte 5,13 Sekunden, verglichen mit 18,77 Sekunden mit dem Standarddolmetscher.
- Matrixmultiplikation: Ein benutzerdefinierter Multithread-Matrixmultiplikationscode erlebte ebenfalls einen Fehler 10-fache Beschleunigungwobei die GIL-freie Model in 4,56 Sekunden fertig battle, verglichen mit 43,95 Sekunden für die Standardversion.
Allerdings habe ich auch erklärt, dass die GIL-freie Model kein Allheilmittel für die Python-Codeentwicklung ist. Überraschenderweise lief eine Multiprozessorversion des Matrixmultiplikationscodes mit Normal-Python schneller (4,49 Sekunden) als mit dem GIL-freien Construct (6,29 Sekunden). Dies unterstreicht die Bedeutung des Testens und Benchmarkings spezifischer Anwendungen, da der Aufwand für das Prozessmanagement in der GIL-freien Model manchmal deren Vorteile zunichte machen kann.
Ich habe auch den Vorbehalt erwähnt, dass nicht alle Python-Bibliotheken von Drittanbietern mit GIL-freiem Python kompatibel sind, und eine URL angegeben, unter der Sie eine Liste inkompatibler Bibliotheken anzeigen können.