Multithreading en Python avec exemple :Apprendre GIL en Python

À tout moment, un philosophe doit soit manger, soit penser.

De plus, un philosophe doit prendre les deux fourchettes adjacentes à lui (c'est-à-dire les fourchettes gauche et droite) avant de pouvoir manger les spaghettis. Le problème de l'impasse survient lorsque les cinq philosophes ramassent leur fourche droite simultanément.

Puisque chacun des philosophes a une fourchette, ils attendront tous que les autres posent leur fourchette. En conséquence, aucun d'entre eux ne pourra manger des spaghettis.

De même, dans un système concurrent, un blocage se produit lorsque différents threads ou processus (philosophes) tentent d'acquérir les ressources système partagées (forks) en même temps. En conséquence, aucun des processus n'a la chance de s'exécuter car ils attendent une autre ressource détenue par un autre processus.

Conditions de course

Une condition de concurrence est un état indésirable d'un programme qui se produit lorsqu'un système exécute deux opérations ou plus simultanément. Par exemple, considérez cette simple boucle for :

i=0; # a global variable
for x in range(100):
    print(i)
    i+=1;

Si vous créez n nombre de threads qui exécutent ce code à la fois, vous ne pouvez pas déterminer la valeur de i (qui est partagée par les threads) lorsque le programme termine son exécution. En effet, dans un environnement multithreading réel, les threads peuvent se chevaucher et la valeur de i qui a été récupérée et modifiée par un thread peut changer entre-temps lorsqu'un autre thread y accède.

Ce sont les deux principales classes de problèmes qui peuvent survenir dans une application python multithread ou distribuée. Dans la section suivante, vous apprendrez à surmonter ce problème en synchronisant les threads.

Synchroniser les fils

Pour gérer les conditions de concurrence, les blocages et autres problèmes liés aux threads, le module de threading fournit le Lock objet. L'idée est que lorsqu'un thread veut accéder à une ressource spécifique, il acquiert un verrou pour cette ressource. Une fois qu'un thread a verrouillé une ressource particulière, aucun autre thread ne peut y accéder tant que le verrou n'est pas relâché. En conséquence, les modifications apportées à la ressource seront atomiques et les conditions de concurrence seront évitées.

Un verrou est une primitive de synchronisation de bas niveau implémentée par le __thread module. A tout moment, un verrou peut être dans l'un des 2 états suivants :verrouillé ou déverrouillé. Il prend en charge deux méthodes :

1. acquérir() Lorsque l'état de verrouillage est déverrouillé, l'appel de la méthodeacquérir () changera l'état en verrouillé et reviendra. Cependant, si l'état est verrouillé, l'appel à buyer() est bloqué jusqu'à ce que la méthode release() soit appelée par un autre thread.
2. release() La méthode release() est utilisée pour définir l'état sur déverrouillé, c'est-à-dire pour libérer un verrou. Il peut être appelé par n'importe quel thread, pas nécessairement celui qui a acquis le verrou.

Voici un exemple d'utilisation de verrous dans vos applications. Lancez votre IDLE et tapez ce qui suit :

import threading
lock = threading.Lock()

def first_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the first funcion')
        lock.release()

def second_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the second funcion')
        lock.release()

if __name__=="__main__":
    thread_one = threading.Thread(target=first_function)
    thread_two = threading.Thread(target=second_function)

    thread_one.start()
    thread_two.start()

    thread_one.join()
    thread_two.join()

Maintenant, appuyez sur F5. Vous devriez voir une sortie comme celle-ci :

EXPLICATION DU CODE

1. Ici, vous créez simplement un nouveau verrou en appelant le threading.Lock() fonction d'usine. En interne, Lock() renvoie une instance de la classe Lock concrète la plus efficace maintenue par la plate-forme.
2. Dans la première instruction, vous acquérez le verrou en appelant la méthodeacquérir(). Lorsque le verrou a été accordé, vous imprimez « verrou acquis » à la console. Une fois que tout le code que vous voulez que le thread exécute est terminé, vous libérez le verrou en appelant la méthode release().

La théorie est bonne, mais comment savez-vous que le verrou a vraiment fonctionné ? Si vous regardez la sortie, vous verrez que chacune des instructions d'impression imprime exactement une ligne à la fois. Rappelez-vous que, dans un exemple précédent, les sorties de print étaient aléatoires car plusieurs threads accédaient à la méthode print() en même temps. Ici, la fonction d'impression n'est appelée qu'après l'acquisition du verrou. Ainsi, les sorties sont affichées une par une et ligne par ligne.

Outre les verrous, Python prend également en charge d'autres mécanismes pour gérer la synchronisation des threads, comme indiqué ci-dessous :

1. Rlocks
2. Sémaphores
3. Conditions
4. Événements, et
5. Obstacles

Global Interpreter Lock (et comment le gérer)

Avant d'entrer dans les détails du GIL de python, définissons quelques termes qui seront utiles pour comprendre la section suivante :

1. Code lié au processeur :il s'agit de tout morceau de code qui sera directement exécuté par le processeur.
2. Code lié aux E/S :il peut s'agir de n'importe quel code qui accède au système de fichiers via le système d'exploitation
3. CPython :c'est l'implémentation de référence de Python et peut être décrit comme l'interpréteur écrit en C et Python (langage de programmation).

Qu'est-ce que GIL en Python ?

Global Interpreter Lock (GIL) en python est un verrou de processus ou un mutex utilisé lors de la gestion des processus. Il s'assure qu'un thread peut accéder à une ressource particulière à la fois et empêche également l'utilisation simultanée d'objets et de bytecodes. Cela profite aux programmes à thread unique dans une augmentation des performances. GIL en python est très simple et facile à mettre en œuvre.

Un verrou peut être utilisé pour s'assurer qu'un seul thread a accès à une ressource particulière à un moment donné.

L'une des caractéristiques de Python est qu'il utilise un verrou global sur chaque processus d'interpréteur, ce qui signifie que chaque processus traite l'interpréteur Python lui-même comme une ressource.

Par exemple, supposons que vous ayez écrit un programme python qui utilise deux threads pour effectuer à la fois des opérations CPU et "E/S". Lorsque vous exécutez ce programme, voici ce qui se passe :

1. L'interpréteur Python crée un nouveau processus et génère les threads
2. Lorsque le thread-1 démarre, il acquiert d'abord le GIL et le verrouille.
3. Si le thread-2 veut s'exécuter maintenant, il devra attendre que le GIL soit libéré même si un autre processeur est libre.
4. Maintenant, supposons que le thread-1 attend une opération d'E/S. À ce moment, il publiera le GIL et thread-2 l'acquerra.
5. Après avoir terminé les opérations d'E/S, si le thread-1 veut s'exécuter maintenant, il devra à nouveau attendre que le GIL soit libéré par le thread-2.

Pour cette raison, un seul thread peut accéder à l'interpréteur à tout moment, ce qui signifie qu'il n'y aura qu'un seul thread exécutant du code python à un moment donné.

Cela convient dans un processeur monocœur car il utiliserait le découpage temporel (voir la première section de ce didacticiel) pour gérer les threads. Cependant, dans le cas de processeurs multicœurs, une fonction liée au processeur s'exécutant sur plusieurs threads aura un impact considérable sur l'efficacité du programme car il n'utilisera pas tous les cœurs disponibles en même temps.

Pourquoi GIL était-il nécessaire ?

Le ramasse-miettes CPython utilise une technique de gestion de la mémoire efficace connue sous le nom de comptage de références. Voici comment cela fonctionne :chaque objet en python a un nombre de références, qui est augmenté lorsqu'il est affecté à un nouveau nom de variable ou ajouté à un conteneur (comme des tuples, des listes, etc.). De même, le nombre de références est diminué lorsque la référence sort de la portée ou lorsque l'instruction del est appelée. Lorsque le nombre de références d'un objet atteint 0, il est ramassé et la mémoire allouée est libérée.

Mais le problème est que la variable de comptage de références est sujette à des conditions de concurrence comme toute autre variable globale. Pour résoudre ce problème, les développeurs de python ont décidé d'utiliser le verrou d'interpréteur global. L'autre option consistait à ajouter un verrou à chaque objet, ce qui aurait entraîné des blocages et une augmentation de la surcharge des appels d'acquisition() et de libération().

Par conséquent, GIL est une restriction importante pour les programmes python multithread exécutant de lourdes opérations liées au processeur (ce qui les rend effectivement monothread). Si vous souhaitez utiliser plusieurs cœurs de processeur dans votre application, utilisez le multitraitement module à la place.

Résumé

• Python prend en charge 2 modules pour le multithreading :
  1. __thread module :il fournit une implémentation de bas niveau pour le threading et est obsolète.
  2. module d'enfilage  :Il fournit une implémentation de haut niveau pour le multithreading et constitue la norme actuelle.
• Pour créer un thread à l'aide du module de threading, vous devez procéder comme suit :
  1. Créer une classe qui étend le Thread classe.
  2. Remplacer son constructeur (__init__).
  3. Remplacer son run() méthode.
  4. Créer un objet de cette classe.
• Un thread peut être exécuté en appelant start() méthode.
• La join() peut être utilisée pour bloquer d'autres threads jusqu'à ce que ce thread (celui sur lequel la jointure a été appelée) termine son exécution.
• Une condition de concurrence se produit lorsque plusieurs threads accèdent ou modifient une ressource partagée en même temps.
• Cela peut être évité en synchronisant les threads.
• Python prend en charge 6 façons de synchroniser les threads :
  1. Verrous
  2. Rlocks
  3. Sémaphores
  4. Conditions
  5. Événements, et
  6. Obstacles
• Les verrous permettent uniquement à un thread particulier qui a acquis le verrou d'entrer dans la section critique.
• Un verrou a 2 méthodes principales :
  1. acquérir() :Il définit l'état de verrouillage sur locked. S'il est appelé sur un objet verrouillé, il bloque jusqu'à ce que la ressource soit libre.
  2. release()  :Il définit l'état de verrouillage sur déverrouillé et revient. S'il est appelé sur un objet déverrouillé, il renvoie false.
• Le verrouillage global de l'interpréteur est un mécanisme par lequel un seul processus d'interpréteur CPython peut s'exécuter à la fois.
• Il a été utilisé pour faciliter la fonctionnalité de comptage de références du ramasse-miettes de CPythons.
• Pour créer des applications Python avec de lourdes opérations liées au processeur, vous devez utiliser le module de multitraitement.