Python 3.14 et la fin du GIL

l’une des sorties les plus attendues de ces derniers temps, est enfin là. La raison en est que plusieurs améliorations intéressantes ont été implémentées dans cette version, notamment :

Sous-interprètes. Ceux-ci sont disponibles en Python depuis 20 ans, mais pour les utiliser, il fallait passer au codage en C. Ils peuvent désormais être utilisés directement à partir de Python lui-même.

Cordes en T. Les chaînes de modèles constituent une nouvelle méthode de traitement des chaînes personnalisées. Ils utilisent la syntaxe familière des f-strings, mais, contrairement aux f-strings, ils renvoient un objet représentant à la fois les parties statiques et interpolées de la chaîne, au lieu d’une simple chaîne.

Un compilateur juste à temps. Il s’agit encore d’une fonctionnalité expérimentale et ne doit pas être utilisée dans les systèmes de production ; cependant, il promet une amélioration des performances pour des cas d’utilisation spécifiques.

Il existe de nombreuses autres améliorations dans Python 3.14, mais cet article ne concerne pas celles que nous avons mentionnées ci-dessus.

Au lieu de cela, nous discuterons de ce qui est probablement la fonctionnalité la plus attendue de cette version : Python à thread libre, également connu sous le nom de Python sans GIL. Notez que Python 3.14 standard fonctionnera toujours avec le GIL activé, mais vous pouvez télécharger (ou créer) une version distincte et gratuite. Je vais vous montrer comment le télécharger et l’installer, et à travers plusieurs exemples de codage, démontrer une comparaison des temps d’exécution entre Python 3.14 standard et sans GIL.

Qu’est-ce que le GIL ?

Beaucoup d’entre vous connaissent le Global Interpreter Lock (GIL) en Python. Le GIL est un mutex (un mécanisme de verrouillage) utilisé pour synchroniser l’accès aux ressources et, en Python, garantit qu’un seul thread exécute le bytecode à la fois.

D’une part, cela présente plusieurs avantages, notamment faciliter la gestion des threads et de la mémoire, éviter les conditions de concurrence critique et intégrer Python aux bibliothèques C/C++.

D’un autre côté, le GIL peut étouffer le parallélisme. Avec le GIL en place, un véritable parallélisme pour les tâches liées au processeur sur plusieurs cœurs de processeur au sein d’un seul processus Python n’est pas possible.

Pourquoi c’est important

En un mot, « performance ».

Étant donné que l’exécution en thread libre peut utiliser simultanément tous les cœurs disponibles sur votre système, le code s’exécutera souvent plus rapidement. En tant que data scientists et ML ou ingénieurs de données, cela s’applique non seulement à votre code mais également au code qui construit les systèmes, les frameworks et les bibliothèques sur lesquels vous comptez.

De nombreuses tâches d’apprentissage automatique et de science des données sont gourmandes en CPU, en particulier lors de la formation des modèles et du prétraitement des données. La suppression du GIL pourrait conduire à des améliorations significatives des performances pour ces tâches liées au processeur.

De nombreuses bibliothèques populaires en Python sont confrontées à des contraintes car elles ont dû contourner le GIL. Sa suppression pourrait entraîner : –

• Implémentations simplifiées et potentiellement plus efficaces de ces bibliothèques
• Nouvelles opportunités d’optimisation dans les bibliothèques existantes
• Développement de nouvelles bibliothèques pouvant tirer pleinement parti du traitement parallèle

Installation de la version Python en thread gratuit

Si vous êtes un utilisateur Linux, la seule façon d’obtenir du threading Python gratuit est de le construire vous-même. Si, comme moi, vous êtes sous Windows (ou macOS), vous pouvez l’installer à l’aide des installateurs officiels du site Python. Au cours du processus, vous aurez la possibilité de personnaliser votre installation. Recherchez une case à cocher pour inclure les binaires à thread libre. Cela installera un interpréteur distinct que vous pourrez utiliser pour exécuter votre code sans le GIL. Je vais montrer comment fonctionne l’installation sur un système Windows 64 bits.

Pour commencer, cliquez sur l’URL suivante :

https://www.python.org/downloads/release/python-3140

Et faites défiler vers le bas jusqu’à ce que vous voyiez un tableau qui ressemble à ceci.

Maintenant, cliquez sur le lien Windows Installer (64 bits). Une fois l’exécutable téléchargé, ouvrez-le et, sur le premier écran d’installation qui s’affiche, cliquez sur le Personnaliser l’installation lien. Notez que j’ai également vérifié le Ajouter Python.exe au chemin case à cocher.

Sur l’écran suivant, sélectionnez les extras facultatifs que vous souhaitez ajouter à l’installation, puis cliquez sur Suivant encore. À ce stade, vous devriez voir un écran comme celui-ci,

Assurez-vous de cocher la case à côté de Téléchargez des binaires gratuits est sélectionné. J’ai également vérifié le Installez Python 3.14 pour tous les utilisateurs option.

Cliquez sur le bouton Installer.

Une fois le téléchargement terminé, dans le dossier d’installation, recherchez un fichier d’application Python avec un « t » à la fin de son nom. Il s’agit de la version de Python sans GIL. Le fichier d’application, appelé Python, est l’exécutable Python standard. Dans mon cas, le Python sans GIL s’appelait Python3.14t. Vous pouvez vérifier qu’il a été correctement installé en tapant ceci dans une ligne de commande.

C:\Users\thoma>python3.14t

Python 3.14.0 free-threading build (tags/v3.14.0:ebf955d, Oct  7 2025, 10:13:09) [MSC v.1944 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 

Si vous voyez cela, vous êtes prêt. Sinon, vérifiez que l’emplacement d’installation a été ajouté à votre variable d’environnement PATH et/ou revérifiez vos étapes d’installation.

Comme nous comparerons les environnements d’exécution Python sans GIL avec les environnements d’exécution Python classiques, nous devons également vérifier que celui-ci est également installé correctement.

C:\Users\thoma>python
Python 3.14.0 (tags/v3.14.0:ebf955d, Oct  7 2025, 10:15:03) [MSC v.1944 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

GIL vs Python sans GIL

Exemple 1 — Trouver des nombres premiers

Tapez ce qui suit dans un fichier de code Python, par exemple example1.py

#
# example1.py
#

import threading
import time
import multiprocessing

def is_prime(n):
    """Check if a number is prime."""
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def find_primes(start, end):
    """Find all prime numbers in the given range."""
    primes = []
    for num in range(start, end + 1):
        if is_prime(num):
            primes.append(num)
    return primes

def worker(worker_id, start, end):
    """Worker function to find primes in a specific range."""
    print(f"Worker {worker_id} starting")
    primes = find_primes(start, end)
    print(f"Worker {worker_id} found {len(primes)} primes")

def main():
    """Main function to coordinate the multi-threaded prime search."""
    start_time = time.time()

    # Get the number of CPU cores
    num_cores = multiprocessing.cpu_count()
    print(f"Number of CPU cores: {num_cores}")

    # Define the range for prime search
    total_range = 2_000_000
    chunk_size = total_range // num_cores

    threads = []
    # Create and start threads equal to the number of cores
    for i in range(num_cores):
        start = i * chunk_size + 1
        end = (i + 1) * chunk_size if i < num_cores - 1 else total_range
        thread = threading.Thread(target=worker, args=(i, start, end))
        threads.append(thread)
        thread.start()

    # Wait for all threads to complete
    for thread in threads:
        thread.join()

    # Calculate and print the total execution time
    end_time = time.time()
    total_time = end_time - start_time
    print(f"All workers completed in {total_time:.2f} seconds")

if __name__ == "__main__":
    main()

Le est_prime la fonction vérifie si un nombre donné est premier.

Le find_primes La fonction trouve tous les nombres premiers dans une plage donnée.

Le travailleur La fonction est la cible de chaque thread, trouvant des nombres premiers dans une plage spécifique.

Le principal La fonction coordonne la recherche principale multithread :

• Il divise la plage totale en nombre de morceaux correspondant au nombre de cœurs du système (32 dans mon cas).
• Crée et démarre 32 threads, chacun recherchant une petite partie de la plage.
• Attend que tous les threads soient terminés.
• Calcule et imprime le temps total d’exécution.

Résultats de chronométrage

Voyons combien de temps il faut pour s’exécuter avec Python standard.

C:\Users\thoma\projects\python-gil>python example1.py
Number of CPU cores: 32
Worker 0 starting
Worker 1 starting
Worker 0 found 6275 primes
Worker 2 starting
Worker 3 starting
Worker 1 found 5459 primes
Worker 4 starting
Worker 2 found 5230 primes
Worker 3 found 5080 primes
...
...
Worker 27 found 4346 primes
Worker 15 starting
Worker 22 found 4439 primes
Worker 30 found 4338 primes
Worker 28 found 4338 primes
Worker 31 found 4304 primes
Worker 11 found 4612 primes
Worker 15 found 4492 primes
Worker 25 found 4346 primes
Worker 26 found 4377 primes
All workers completed in 3.70 seconds

Maintenant, avec la version sans GIL :

C:\Users\thoma\projects\python-gil>python3.14t example1.py
Number of CPU cores: 32
Worker 0 starting
Worker 1 starting
Worker 2 starting
Worker 3 starting
...
...
Worker 19 found 4430 primes
Worker 29 found 4345 primes
Worker 30 found 4338 primes
Worker 18 found 4520 primes
Worker 26 found 4377 primes
Worker 27 found 4346 primes
Worker 22 found 4439 primes
Worker 23 found 4403 primes
Worker 31 found 4304 primes
Worker 28 found 4338 primes
All workers completed in 0.35 seconds

C’est un début impressionnant. Une amélioration de 10x du temps d’exécution.

Exemple 2 — Lecture de plusieurs fichiers simultanément.

Dans cet exemple, nous utiliserons le modèle concurrent.futures pour lire plusieurs fichiers texte simultanément, compter et afficher le nombre de lignes et de mots dans chacun.

Avant de faire cela, nous avons besoin de traiter certains fichiers de données. Vous pouvez utiliser le code Python suivant pour ce faire. Il génère chacune 1 000 000 de phrases aléatoires et absurdes et les écrit dans 20 fichiers texte distincts, sentences_01.txt, sentences_02.txt, etc.

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" # Directory to save the files

# --- 1. Generate a pool of words ---
# Using a small list of common words for variety.
# In a real scenario, you might load a much larger dictionary.
word_pool = [
    "the", "be", "to", "of", "and", "a", "in", "that", "have", "i",
    "it", "for", "not", "on", "with", "he", "as", "you", "do", "at",
    "this", "but", "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", "just", "him", "know", "take",
    "people", "into", "year", "your", "good", "some", "could", "them", "see", "other",
    "than", "then", "now", "look", "only", "come", "its", "over", "think", "also",
    "back", "after", "use", "two", "how", "our", "work", "first", "well", "way",
    "even", "new", "want", "because", "any", "these", "give", "day", "most", "us",
    "apple", "banana", "car", "house", "computer", "phone", "coffee", "water", "sky", "tree",
    "happy", "sad", "big", "small", "fast", "slow", "red", "blue", "green", "yellow"
]

# Ensure output directory exists
os.makedirs(OUTPUT_DIR, exist_ok=True)

print(f"Starting to generate {NUM_FILES} files, each with {SENTENCES_PER_FILE:,} sentences.")
print(f"Total sentences to generate: {NUM_FILES * SENTENCES_PER_FILE:,}")
start_time = time.time()

for file_idx in range(NUM_FILES):
    file_name = os.path.join(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 range(SENTENCES_PER_FILE):
            # 2. Construct fake sentences
            num_words = random.randint(WORDS_PER_SENTENCE_MIN, WORDS_PER_SENTENCE_MAX)
            
            # Randomly pick words
            sentence_words = random.choices(word_pool, k=num_words)
            
            # Join words, capitalize first, add a period
            sentence = " ".join(sentence_words).capitalize() + ".\n"
            
            # 3. Write to file
            f.write(sentence)
            
            # Optional: Print progress for large files
            if (sentence_idx + 1) % 100_000 == 0:
                print(f"  {sentence_idx + 1:,} sentences written to {file_name}...")
                
    file_end_time = time.time()
    print(f"Finished {file_name} in {file_end_time - file_start_time:.2f} seconds.")

total_end_time = time.time()
print(f"\nAll files generated! Total time: {total_end_time - start_time:.2f} seconds.")
print(f"Files saved in the '{OUTPUT_DIR}' directory.")

Voici à quoi ressemble le début du fichier sentences_01.txt :

New then coffee have who banana his their how year also there i take.
Phone go or with over who one at phone there on will.
With or how my us him our sad as do be take well way with green small these.
Not from the two that so good slow new.
See look water me do new work new into on which be tree how an would out sad.
By be into then work into we they sky slow that all who also.
Come use would have back from as after in back he give there red also first see.
Only come so well big into some my into time its banana for come or what work.
How only coffee out way to just tree when by there for computer work people sky by this into.
Than say out on it how she apple computer us well then sky sky day by other after not.
You happy know a slow for for happy then also with apple think look go when.
As who for than two we up any can banana at.
Coffee a up of up these green small this us give we.
These we do because how know me computer banana back phone way time in what.

OK, nous pouvons maintenant chronométrer le temps qu’il faut pour lire ces fichiers. Voici le code que nous allons tester. Il lit simplement chaque fichier, compte les lignes et les mots et affiche les résultats.

import concurrent.futures
import os
import time

def process_file(filename):
    """
    Process a single file, returning its line count and word count.
    """
    try:
        with open(filename, 'r') as file:
            content = file.read()
            lines = content.split('\n')
            words = content.split()
            return filename, len(lines), len(words)
    except Exception as e:
        return filename, -1, -1  # Return -1 for both counts if there's an error

def main():
    start_time = time.time()  # Start the timer

    # List to hold our files
    files = [f"./data/sentences_{i:02d}.txt" for i in range(1, 21)]  # Assumes 20 files named file_1.txt to file_20.txt

    # Use a ThreadPoolExecutor to process files in parallel
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
        # Submit all file processing tasks
        future_to_file = {executor.submit(process_file, file): file for file in files}

        # Process results as they complete
        for future in concurrent.futures.as_completed(future_to_file):
            file = future_to_file[future]
            try:
                filename, line_count, word_count = future.result()
                if line_count == -1:
                    print(f"Error processing {filename}")
                else:
                    print(f"{filename}: {line_count} lines, {word_count} words")
            except Exception as exc:
                print(f'{file} generated an exception: {exc}')

    end_time = time.time()  # End the timer
    print(f"Total execution time: {end_time - start_time:.2f} seconds")

if __name__ == "__main__":
    main()

Résultats de chronométrage

Python régulier d’abord.

C:\Users\thoma\projects\python-gil>python example2.py

./data/sentences_09.txt: 1000001 lines, 14003319 words
./data/sentences_01.txt: 1000001 lines, 13999989 words
./data/sentences_05.txt: 1000001 lines, 13998447 words
./data/sentences_07.txt: 1000001 lines, 14004961 words
./data/sentences_02.txt: 1000001 lines, 14009745 words
./data/sentences_10.txt: 1000001 lines, 14000166 words
./data/sentences_06.txt: 1000001 lines, 13995223 words
./data/sentences_04.txt: 1000001 lines, 14005683 words
./data/sentences_03.txt: 1000001 lines, 14004290 words
./data/sentences_12.txt: 1000001 lines, 13997193 words
./data/sentences_08.txt: 1000001 lines, 13995506 words
./data/sentences_15.txt: 1000001 lines, 13998555 words
./data/sentences_11.txt: 1000001 lines, 14001299 words
./data/sentences_14.txt: 1000001 lines, 13998347 words
./data/sentences_13.txt: 1000001 lines, 13998035 words
./data/sentences_19.txt: 1000001 lines, 13999642 words
./data/sentences_20.txt: 1000001 lines, 14001696 words
./data/sentences_17.txt: 1000001 lines, 14000184 words
./data/sentences_18.txt: 1000001 lines, 13999968 words
./data/sentences_16.txt: 1000001 lines, 14000771 words
Total execution time: 18.77 seconds

Maintenant pour la version sans GIL

C:\Users\thoma\projects\python-gil>python3.14t example2.py

./data/sentences_02.txt: 1000001 lines, 14009745 words
./data/sentences_03.txt: 1000001 lines, 14004290 words
./data/sentences_08.txt: 1000001 lines, 13995506 words
./data/sentences_07.txt: 1000001 lines, 14004961 words
./data/sentences_04.txt: 1000001 lines, 14005683 words
./data/sentences_05.txt: 1000001 lines, 13998447 words
./data/sentences_01.txt: 1000001 lines, 13999989 words
./data/sentences_10.txt: 1000001 lines, 14000166 words
./data/sentences_06.txt: 1000001 lines, 13995223 words
./data/sentences_09.txt: 1000001 lines, 14003319 words
./data/sentences_12.txt: 1000001 lines, 13997193 words
./data/sentences_11.txt: 1000001 lines, 14001299 words
./data/sentences_18.txt: 1000001 lines, 13999968 words
./data/sentences_14.txt: 1000001 lines, 13998347 words
./data/sentences_13.txt: 1000001 lines, 13998035 words
./data/sentences_16.txt: 1000001 lines, 14000771 words
./data/sentences_19.txt: 1000001 lines, 13999642 words
./data/sentences_15.txt: 1000001 lines, 13998555 words
./data/sentences_17.txt: 1000001 lines, 14000184 words
./data/sentences_20.txt: 1000001 lines, 14001696 words
Total execution time: 5.13 seconds

Pas aussi impressionnant que notre premier exemple, mais toujours très bon, montrant une amélioration de plus de 3 fois.

Exemple 3 — multiplication matricielle

Nous utiliserons le filetage module pour cela. Voici le code que nous allons exécuter.

import threading
import time
import os

def multiply_matrices(A, B, result, start_row, end_row):
    """Multiply a submatrix of A and B and store the result in the corresponding submatrix of result."""
    for i in range(start_row, end_row):
        for j in range(len(B[0])):
            sum_val = 0
            for k in range(len(B)):
                sum_val += A[i][k] * B[k][j]
            result[i][j] = sum_val

def main():
    """Main function to coordinate the multi-threaded matrix multiplication."""
    start_time = time.time()

    # Define the size of the matrices
    size = 1000
    A = [[1 for _ in range(size)] for _ in range(size)]
    B = [[1 for _ in range(size)] for _ in range(size)]
    result = [[0 for _ in range(size)] for _ in range(size)]

    # Get the number of CPU cores to decide on the number of threads
    num_threads = os.cpu_count()
    print(f"Number of CPU cores: {num_threads}")

    chunk_size = size // num_threads

    threads = []
    # Create and start threads
    for i in range(num_threads):
        start_row = i * chunk_size
        end_row = size if i == num_threads - 1 else (i + 1) * chunk_size
        thread = threading.Thread(target=multiply_matrices, args=(A, B, result, start_row, end_row))
        threads.append(thread)
        thread.start()

    # Wait for all threads to complete
    for thread in threads:
        thread.join()

    end_time = time.time()

    # Just print a small corner to verify
    print("Top-left 5x5 corner of the result matrix:")
    for r_idx in range(5):
        print(result[r_idx][:5])

    print(f"Total execution time (matrix multiplication): {end_time - start_time:.2f} seconds")

if __name__ == "__main__":
    main()

Le code effectue la multiplication matricielle de deux matrices 1 000 × 1 000 en parallèle à l’aide de plusieurs cœurs de processeur. Il divise la matrice de résultat en morceaux, attribue chaque morceau à un processus distinct (égal au nombre de cœurs de processeur) et chaque processus calcule indépendamment la partie qui lui est attribuée de la multiplication matricielle. Enfin, il attend la fin de tous les processus et rapporte le temps d’exécution total, démontrant comment tirer parti du multitraitement pour accélérer les tâches liées au processeur.

Résultats de chronométrage

Python régulier :

C:\Users\thoma\projects\python-gil>python example3.py
Number of CPU cores: 32
Top-left 5x5 corner of the result 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]
Total execution time (matrix multiplication): 43.95 seconds

Python sans GIL :

C:\Users\thoma\projects\python-gil>python3.14t example3.py
Number of CPU cores: 32
Top-left 5x5 corner of the result 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]
Total execution time (matrix multiplication): 4.56 seconds

Une fois de plus, nous obtenons une amélioration presque 10 fois supérieure en utilisant Python sans GIL. Pas trop mal.

Sans GIL, ce n’est pas toujours mieux.

Un point intéressant à noter est que sur ce dernier test, je l’ai également essayé avec une version multitraitement du code. Il s’est avéré que le Python standard était nettement plus rapide (28 %) que le Python sans GIL. Je ne présenterai pas le code, juste les résultats,

Horaires

Python régulier d’abord (multitraitement).

C:\Users\thoma\projects\python-gil>python example4.py
Number of CPU cores: 32
Top-left 5x5 corner of the result 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]
Total execution time (matrix multiplication): 4.49 seconds

Version sans GIL (multitraitement)

C:\Users\thoma\projects\python-gil>python3.14t example4.py
Number of CPU cores: 32
Top-left 5x5 corner of the result 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]
Total execution time (matrix multiplication): 6.29 seconds

Comme toujours dans ces situations, il est important de tester minutieusement.

Gardez à l’esprit que ces derniers exemples sont juste tests pour montrer la différence entre GIL et Python sans GIL. Utiliser une bibliothèque externe, telle que NumPy, pour effectuer une multiplication matricielle serait au moins un ordre de grandeur plus rapide que l’une ou l’autre.

Un autre point à noter si vous décidez d’utiliser Python en thread libre dans vos charges de travail est que toutes les bibliothèques tierces que vous souhaiterez peut-être utiliser ne sont pas compatibles avec lui. La liste des bibliothèques incompatibles est petite et diminue à chaque version, mais c’est quelque chose à garder à l’esprit. Pour en consulter la liste, veuillez cliquer sur le lien ci-dessous.

https://ft-checker.com

Résumé

Dans cet article, nous discutons d’une fonctionnalité potentiellement révolutionnaire de la dernière version de Python 3.14 : l’introduction d’une version facultative « free-threaded », qui supprime le Global Interpreter Lock (GIL). Le GIL est un mécanisme du Python standard qui simplifie la gestion de la mémoire en garantissant qu’un seul thread exécute le bytecode Python à la fois. Tout en reconnaissant que cela peut être utile dans certains cas, cela empêche un véritable traitement parallèle sur les processeurs multicœurs pour les tâches gourmandes en CPU.

La suppression du GIL dans la version free-thread vise principalement à améliorer performance. Cela peut être particulièrement utile pour les data scientists et les ingénieurs en apprentissage automatique dont le travail implique souvent des opérations liées au processeur, telles que la formation de modèles et le prétraitement des données. Ce changement permet au code Python d’utiliser simultanément tous les cœurs de processeur disponibles au sein d’un seul processus, ce qui pourrait entraîner des améliorations significatives de la vitesse.

Pour démontrer l’impact, l’article présente plusieurs comparaisons de performances :

• Trouver des nombres premiers : Un script multithread a vu un drame Augmentation des performances 10xavec un temps d’exécution passant de 3,70 secondes en Python standard à seulement 0,35 seconde dans la version sans GIL.
• Lire plusieurs fichiers simultanément : Une tâche liée aux E/S utilisant un pool de threads pour traiter 20 gros fichiers texte était terminée 3 fois plus rapidecomplétant en 5,13 secondes contre 18,77 secondes avec l’interprète standard.
• Multiplication matricielle : Un code de multiplication matricielle multithread personnalisé a également connu un problème Accélération 10xla version sans GIL terminant en 4,56 secondes, contre 43,95 secondes pour la version standard.

Cependant, j’ai également expliqué que la version sans GIL n’est pas une panacée pour le développement de code Python. De manière surprenante, une version multitraitement du code de multiplication matricielle s’est exécutée plus rapidement avec Python standard (4,49 secondes) qu’avec la version sans GIL (6,29 secondes). Cela souligne l’importance de tester et d’évaluer des applications spécifiques, car la surcharge de gestion des processus dans la version sans GIL peut parfois annuler ses avantages.

J’ai également mentionné l’avertissement selon lequel toutes les bibliothèques Python tierces ne sont pas compatibles avec Python sans GIL et j’ai donné une URL où vous pouvez afficher une liste des bibliothèques incompatibles.