import threading
import time
 
# Definir um recurso compartilhado
contador = 0
 
# Definir um bloqueio de exclusão mútua
lock = threading.Lock()
 
# Função para incrementar o contador usando primitivas bloqueantes
def incrementar_bloqueante():
    global contador
    # Adquirir o bloqueio
    lock.acquire()
    try:
        # Incrementar o contador
        contador += 1
        # Simular uma operação de E/S
        time.sleep(1)
    finally:
        # Liberar o bloqueio
        lock.release()
 
 
# Função para incrementar o contador usando primitivas não bloqueantes
def incrementar_nao_bloqueante():
    global contador
    # Tentar adquirir o bloqueio sem bloquear
    if lock.acquire(blocking=False):
        try:
            # Incrementar o contador
            contador += 1
            # Simular uma operação de E/S
            time.sleep(1)
        finally:
            # Liberar o bloqueio
            lock.release()
    else:
        # Se o bloqueio não estiver disponível, imprimir uma mensagem
        print("Bloqueio não disponível. Não foi possível incrementar o contador.")
 
 
 
# Criar threads para executar as funções
thread_bloqueante = threading.Thread(target=incrementar_bloqueante)
thread_nao_bloqueante = threading.Thread(target=incrementar_nao_bloqueante)
#extra
thread_bloqueante2 = threading.Thread(target=incrementar_bloqueante)
 
# Iniciar as threads
thread_bloqueante.start()
thread_nao_bloqueante.start()
#extra
thread_bloqueante2.start()
 
# Esperar até que as threads terminem
thread_bloqueante.join()
#thread_nao_bloqueante.join()
#extra
#thread_bloqueante2.join()
 
# Imprimir o valor final do contador
print(f"Valor final do contador: {contador}")
 

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