Apprivoiser la bête GIL de Python : l'art de maîtriser la concurrence

python, GIL, concurrency, multi-threading, multi-processus

Le Global Interpreter Lock

(GIL) de Python est un mécanisme intégré qui garantit qu'un seul thread peut exécuter le bytecode Python à la fois. Ce verrou sert à empêcher la corruption des données car il empêche plusieurs threads de modifier les données partagées en même temps.

Restrictions GIL

Bien que le GIL soit essentiel pour garantir l'intégrité des données, il impose également des limitations importantes à la concurrence de Python :

• Séquentialité : GIL force tous les threads à s'exécuter séquentiellement, limitant le parallélisme des programmes concurrents Python.
• Boulot d'étranglement : Lorsqu'un thread est en attente dans une opération d'E/S ou une autre opération de blocage, le GIL empêche les autres threads de s'exécuter. Cela peut entraîner des retards dans les tâches et une dégradation des performances.

Surmonter les limitations du GIL

Bien que le GIL ne puisse pas être complètement contourné, il existe des techniques pour atténuer son impact sur la concurrence :

1. Multi-processus

Le multitraitement utilise plusieurs processus du

système d'exploitation au lieu de threads Python pour obtenir la concurrence. Puisque chaque processus possède son propre GIL, ils peuvent s'exécuter simultanément sans aucun conflit de verrouillage :

import multiprocessing

def task(num):
print(f"Process {num}: {num * num}")

if __name__ == "__main__":
processes = [multiprocessing.Process(target=task, args=(i,)) for i in range(4)]
for process in processes:
process.start()
for process in processes:
process.join()

2. Multithreading et files d'attente

Utilisez plusieurs threads et files d'attente pour obtenir le parallélisme tout en évitant les conflits GIL. Les threads placent les tâches dans des files d'attente, tandis que d'autres threads récupèrent les tâches de la file d'attente et les exécutent :

import threading
import queue

queue = queue.Queue()

def producer():
for i in range(10):
queue.put(i)

def consumer():
while not queue.empty():
item = queue.get()
print(f"Thread: {item * item}")

threads = [threading.Thread(target=producer), threading.Thread(target=consumer)]
for thread in threads:
thread.start()
for thread in threads:
thread.join()

3. Greenlets

Les Greenlets sont des coroutines, elles permettent de mettre en pause et de reprendre des fonctions dans un seul thread. Étant donné que les Greenlets ne sont pas liés par le GIL, ils peuvent obtenir la concurrence sans conflit de verrouillage :

import gevent

def task(num):
print(f"Greenlet {num}: {num * num}")

gevent.joinall([gevent.spawn(task, i) for i in range(4)])

4. Extension C/C++

Pour les applications simultanées nécessitant des performances élevées, les extensions

C/C++ peuvent être écrites et intégrées avec Python. Le code C/c++ n'est pas affecté par le GIL et permet donc un parallélisme plus rapide :

#include <Python.h>

static PyObject* py_task(PyObject* self, PyObject* args) {
int num;
if (!PyArg_ParseTuple(args, "i", &num)) {
return NULL;
}

// 执行任务
int result = num * num;

return Py_BuildValue("i", result);
}

static PyMethodDef methods[] = {
{"task", py_task, METH_VARARGS, "PerfORM a task in a C extension"},
{NULL, NULL, 0, NULL}
};

static PyModuleDef module = {
PyModuleDef_HEAD_INIT,
"c_extension",
"C extension for parallel task execution",
-1,
methods
};

PyMODINIT_FUNC PyInit_c_extension(void) {
return PyModule_Create(&module);
}

Résumé

Le GIL de Python, bien qu’essentiel pour garantir l’intégrité des données, limite la concurrence. En employant des stratégies telles que le multitraitement, le multithreading et les files d'attente, les Greenlets ou les extensions C/C++, vous pouvez surmonter les limites du GIL et libérer tout le potentiel de la concurrence Python. Cependant, lors de l’utilisation de ces technologies, leurs avantages, inconvénients et pertinence doivent être soigneusement étudiés.

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!