Mutex en Python

Mutex signifie exclusion mutuelle. Cela signifie qu’à un moment donné, un seul thread peut utiliser une ressource particulière. Si un programme a plusieurs threads, alors l’exclusion mutuelle restreint les threads à utiliser cette ressource particulière simultanément. Il verrouille les autres threads et restreint leur entrée dans la section critique.

Ce tutoriel démontrera l’utilisation de mutex en Python.

Pour implémenter mutex en Python, on peut utiliser la fonction lock() du module threading pour verrouiller les threads. Si le deuxième thread est sur le point de se terminer avant le premier thread, il attendra que le premier thread se termine. Nous verrouillons le deuxième thread pour nous en assurer, puis nous le faisons attendre la fin du premier thread. Et lorsque le premier thread est terminé, on libère le verrou du deuxième thread.

Voir le code ci-dessous.

import threading
import time
import random

mutex = threading.Lock()


class thread_one(threading.Thread):
    def run(self):
        global mutex
        print("The first thread is now sleeping")
        time.sleep(random.randint(1, 5))
        print("First thread is finished")
        mutex.release()


class thread_two(threading.Thread):
    def run(self):
        global mutex
        print("The second thread is now sleeping")
        time.sleep(random.randint(1, 5))
        mutex.acquire()
        print("Second thread is finished")


mutex.acquire()
t1 = thread_one()
t2 = thread_two()
t1.start()
t2.start()

Production:

The first thread is now sleeping
The second thread is now sleeping
First thread is finished
Second thread is finished

Dans ce code, le deuxième thread n’est pas libéré tant que le premier thread n’est pas terminé. Le deuxième thread attend le premier thread dans le verrou. Le mot-clé global est utilisé dans le code car le thread l’utilise à la fois. Notez que l’instruction print vient juste après l’instruction acquire, pas avant, car tant que le thread attend, il n’est pas encore terminé.

Par conséquent, il est très important de verrouiller les threads. Sinon, il peut planter l’application si deux threads partagent la même ressource simultanément.