L'évolution du GIL : le paysage changeant de Python simultané

L'interprète global

lock (GIL) dans python est un sujet très débattu depuis sa création. Bien que le GIL garantisse que l'interpréteur Python n'exécute qu'un seul thread à la fois, maintenant ainsi la sécurité de la mémoire, il limite également la possibilité de concurrence. Cet article explorera l'évolution de GIL depuis sa conception initiale jusqu'à son statut actuel et ses orientations futures.

Origine du GIL

GIL a été initialement introduit dans Python 1.5 pour empêcher plusieurs threads de modifier le même objet simultanément, entraînant une corruption des données. À l’époque, Python était principalement utilisé sur des ordinateurs monocœur et le GIL n’était pas un facteur limitant majeur.

Restrictions GIL

Avec la popularité des ordinateurs multicœurs, les limites de GIL sont devenues évidentes. Étant donné que le GIL n'autorise qu'un seul thread à s'exécuter à la fois, le code concurrent ne peut s'exécuter que sur un seul cœur. Cela peut entraîner des problèmes de performances pour les applications qui nécessitent beaucoup de concurrence.

Alternatives au GIL

Pour pallier aux limites du GIL, un certain nombre d'alternatives ont été développées :

• Processus multiples : Créez plusieurs processus Python, chacun avec son propre GIL. Cela permet une véritable concurrence, mais peut être moins efficace en raison de la surcharge de communication entre les processus.
• Bibliothèques tierces : telles que , qui fournissent des concurrent.futures 和 multiprocessingoutils pour l'exécution parallèle et simultanée de tâches. Ces bibliothèques utilisent un pool de processus ou thread pool pour gérer le GIL, permettant d'exécuter du code sur plusieurs cœurs.
• Coroutine (coroutine) : Coroutine est un mécanisme de concurrence léger qui permet de suspendre et de reprendre plusieurs tâches au sein d'un thread. Les coroutines ne nécessitent pas le GIL, mais elles reposent sur une planification manuelle et un changement de contexte.

Améliorations de GIL dans Python 3.8

Dans Python 3.8, des améliorations majeures du GIL ont été introduites pour améliorer les performances de concurrence. Ces améliorations incluent :

• Version du GIL basée sur les événements : Le GIL peut désormais être libéré lors d'événements de boucle d'événements, tels que les opérations d'E/S. Cela permet à d'autres threads de s'exécuter pendant que la boucle d'événements gère les opérations d'E/S.
• Latence GIL adaptative : La latence GIL s'ajuste en fonction de l'utilisation du multi-threading par votre application. Lorsque vous utilisez moins de threads, la latence GIL est plus longue, permettant plus de concurrence.

Améliorations de GIL dans Python 3.10

Python 3.10 introduit d'autres améliorations du GIL appelées

Fine-grained GIL. Le GIL à granularité fine réduit la portée du GIL à des blocs de code plus petits, permettant un contrôle de concurrence plus fin. Ceci est particulièrement avantageux pour les applications qui nécessitent une simultanéité lors d’opérations atomiques fréquentes.

Perspectives d'avenir

L'avenir de GIL reste incertain. Bien que l’équipe de développement Python s’engage à améliorer continuellement le GIL, il est possible qu’il soit entièrement supprimé dans une future version. Des alternatives, telles que le multitraitement et les coroutines, continuent de mûrir et pourraient remplacer le GIL en tant que mécanisme privilégié pour la concurrence en Python.

Code démo

Utilisez pour le traitement parallèle : concurrent.futures

import concurrent.futures

def task(n):
return n * n

with concurrent.futures.ProcessPoolExecutor() as executor:
results = executor.map(task, range(10))

Utilisez async<strong>io<code>async<strong class="keylink">io</strong> pour la coroutine :

import asyncio

async def task(n):
return n * n

async def main():
tasks = [task(n) for n in range(10)]
results = await asyncio.gather(*tasks)

asyncio.run(main())

Résumé

L'évolution de GIL dans la concurrence Python est un problème complexe et difficile. Alors que Python met de plus en plus l’accent sur le traitement multicœur et le calcul haute performance, l’avenir du GIL continuera d’être surveillé de près. Les développeurs doivent peser les avantages et les limites du GIL et choisir le mécanisme de concurrence approprié pour leur application particulière. En comprenant l'évolution du GIL, les développeurs peuvent prendre des décisions éclairées et créer des applications Python simultanées efficaces et évolutives.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!