Mutex em Python

Mutex significa exclusão mútua. Isso significa que em um determinado momento específico, apenas um encadeamento pode usar um determinado recurso. Se um programa tiver vários threads, a exclusão mútua restringe os threads para usar esse recurso específico simultaneamente. Ele bloqueia os outros threads e restringe sua entrada na seção crítica.

Este tutorial demonstrará o uso de mutex em Python.

Para implementar mutex em Python, podemos usar a função lock() do módulo threading para bloquear os threads. Se o segundo encadeamento estiver prestes a terminar antes do primeiro encadeamento, ele aguardará o término do primeiro. Bloqueamos o segundo encadeamento para garantir isso e, em seguida, o fazemos aguardar o término do primeiro encadeamento. E quando o primeiro encadeamento é concluído, liberamos o bloqueio do segundo encadeamento.

Veja o código fornecido abaixo.

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()

Produção:

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

Nesse código, o segundo encadeamento não é liberado até que o primeiro seja concluído. O segundo encadeamento aguarda o primeiro encadeamento na fechadura. A palavra-chave global é usada no código porque ambas as threads a usam. Observe que a instrução print vem logo após a instrução acquire, não antes, porque enquanto a thread estiver esperando, ela ainda não terminou.

Portanto, é muito importante travar os fios. Caso contrário, ele pode travar o aplicativo se dois threads compartilharem o mesmo recurso simultaneamente.