GIL Gallows Survivor : le voyage impossible de Python simultané

GIL (Global Interpreter Lock) est le composant principal de l'interpréteur python, qui garantit qu'un seul thread exécute le bytecode Python en même temps. Bien que le GIL fournisse la sécurité des threads, il limite également le potentiel de Python en matière de programmation simultanée, car les threads ne peuvent s'exécuter qu'en série.

Pour surmonter les limites du GIL, diverses techniques ont vu le jour pour contourner son verrouillage et réaliser la

concurrence. Ces technologies incluent :

Multi-threading :

Multi-threading est une technologie qui utilise plusieurs threads CPU pour exécuter du code en parallèle. En Python, les threads peuvent être créés et gérés à l'aide du module . Cependant, le GIL limite la capacité de chaque thread à exécuter du code Python simultanément. threading

import threading

def task():
# 执行耗时的操作

threads = []
for i in range(4):
thread = threading.Thread(target=task)
threads.append(thread)
thread.start()

for thread in threads:
thread.join()

Ce code crée 4 threads, mais à cause du GIL, ils ne peuvent pas exécuter la fonction

simultanément. task()

Multi-processus :

Le multitraitement est une technologie qui utilise plusieurs processus du

système d'exploitation pour exécuter du code en parallèle. En Python, les processus peuvent être créés et gérés à l'aide du module . Contrairement aux threads, les processus possèdent leur propre interpréteur Python et ne sont donc pas limités par le GIL. multiprocessing

import multiprocessing

def task():
# 执行耗时的操作

processes = []
for i in range(4):
process = multiprocessing.Process(target=task)
processes.append(process)
process.start()

for process in processes:
process.join()

Ce code crée 4 processus, et ils peuvent exécuter

fonctions simultanément sur différents cœurs de processeur sans être limités par le GIL. task()

GIL Lift :

GIL Release

Toolpermet au code Python de libérer temporairement le GIL, permettant à d'autres threads ou processus d'exécuter du code Python. Ceci peut être réalisé en utilisant . concurrent.futures 模块中的 ThreadPoolExecutor 或 ProcessPoolExecutor

from concurrent.futures import ThreadPoolExecutor

def task():
# 执行耗时的操作

with ThreadPoolExecutor(max_workers=4) as executor:
executor.submit(task)# 提交任务到线程池

Ce code utilise le pool de threads pour exécuter la fonction

, tandis que le thread principal peut continuer à effectuer d'autres tâches. task()

Conclusion :

Bien que le GIL limite la concurrence native de Python, en tirant parti des techniques de multi-threading, de multi-traitement et de déroulement GIL, les

développeurs peuvent contourner son verrouillage et exploiter pleinement le potentiel de concurrence de Python. Ces techniques permettent à Python d'effectuer des tâches parallèles, améliorant ainsi les performances et l'évolutivité des applications.

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!