Proteger estado compartilhado entre threads

vagas = 1


def reservar() -> bool:
    global vagas
    if vagas > 0:           # 1. leitura e decisão
        vagas -= 1         # 2. atualização
        return True
    return False

from concurrent.futures import ThreadPoolExecutor
from threading import Event

vagas = 1
leitura_ana = Event()
leitura_bia = Event()
pode_atualizar = Event()


def reservar(nome: str, leitura_concluida: Event) -> bool:
    global vagas

    vagas_observadas = vagas
    leitura_concluida.set()

    if not pode_atualizar.wait(timeout=1):
        raise RuntimeError(f"{nome}: autorização não recebida")

    if vagas_observadas > 0:
        vagas -= 1
        print(f"{nome}: reserva aceita; vagas agora = {vagas}")
        return True

    print(f"{nome}: reserva recusada")
    return False


with ThreadPoolExecutor(max_workers=2) as executor:
    futura_ana = executor.submit(reservar, "Ana", leitura_ana)
    futura_bia = executor.submit(reservar, "Bia", leitura_bia)

    try:
        ana_leu = leitura_ana.wait(timeout=1)
        bia_leu = leitura_bia.wait(timeout=1)
        if not (ana_leu and bia_leu):
            raise RuntimeError("Nem todas as leituras foram confirmadas")

        pode_atualizar.set()

        resultados = [futura_ana.result(), futura_bia.result()]
        print(f"Aceites: {sum(resultados)}; vagas finais: {vagas}")
    finally:
        pode_atualizar.set()
        leitura_ana.set()
        leitura_bia.set()

from threading import Lock


class Vagas:
    def __init__(self, capacidade: int) -> None:
        self._disponiveis = capacidade
        self._lock = Lock()

    def reservar(self) -> bool:
        with self._lock:
            if self._disponiveis == 0:
                return False

            self._disponiveis -= 1
            return True

import threading

class Vagas:
    def __init__(self, capacidade: int) -> None:
        self.disponiveis = capacidade

    def reservar(self) -> bool:
        lock = threading.Lock()  # novo Lock a cada chamada
        with lock:
            if self.disponiveis == 0:
                return False
            self.disponiveis -= 1
            return True

    def devolver(self) -> None:
        with threading.Lock():  # outro Lock, diferente do anterior
            self.disponiveis += 1

import threading

class Vagas:
    def __init__(self, capacidade: int) -> None:
        self._disponiveis = capacidade
        self._lock = threading.Lock()

    def reservar(self) -> bool:
        with self._lock:
            if self._disponiveis == 0:
                return False
            self._disponiveis -= 1
            return True

    def devolver(self) -> None:
        with self._lock:
            self._disponiveis += 1

    def disponiveis(self) -> int:
        with self._lock:
            return self._disponiveis

from threading import Lock


class Agenda:
    def __init__(self, vagas: int) -> None:
        self._vagas = vagas
        self._lock = Lock()

    def reservar(self, nome: str) -> bool:
        # Trabalho independente: não precisa do estado protegido.
        solicitacao = nome.strip().title()

        with self._lock:
            # Consulta, decisão e alteração formam uma única regra.
            if self._vagas == 0:
                return False

            self._vagas -= 1
            comprovante = f"Reserva confirmada para {solicitacao}"

        # Trabalho potencialmente lento: Lock já foi liberado.
        enviar_confirmacao(comprovante)
        return True


def enviar_confirmacao(comprovante: str) -> None:
    print(comprovante)

from threading import Lock

lock_a = Lock()
lock_b = Lock()

# NÃO EXECUTE: ordens opostas podem formar um ciclo.
def transferir_ab_inseguro():
    with lock_a:
        with lock_b:
            atualizar()

def transferir_ba_inseguro():
    with lock_b:
        with lock_a:
            atualizar()

# Seguro quanto à ordem: toda operação adquire A antes de B.
def atualizar_dois_recursos():
    with lock_a:
        with lock_b:
            atualizar()

# transferir_ab() e transferir_ba() devem chamar atualizar_dois_recursos().

from threading import Lock

class Estoque:
    def __init__(self):
        self._lock = Lock()
        self._vagas = 1

    # NÃO EXECUTE: reservar() já mantém self._lock.
    def reservar(self):
        with self._lock:
            return self._tem_vaga()  # tenta adquirir o mesmo Lock

    def _tem_vaga(self):
        with self._lock:
            return self._vagas > 0

    # Correção: método interno pressupõe Lock já adquirido.
    def _tem_vaga_protegida(self):
        return self._vagas > 0

# Padrão inseguro:
# with lock:
#     futuro = executor.submit(trabalhar_com_recurso)
#     resultado = futuro.result()  # trabalhador precisa de lock
# Correção: saia do with antes de futuro.result(),
# ou reorganize para o trabalhador não depender desse Lock.

from concurrent.futures import ThreadPoolExecutor


def contar_pares(numeros: tuple[int, ...]) -> int:
    # Lê apenas a entrada recebida e devolve um resultado independente.
    return sum(numero % 2 == 0 for numero in numeros)


lotes = ((2, 3, 4), (5, 6, 7), (8, 9, 10))

with ThreadPoolExecutor(max_workers=3) as executor:
    futuros = [executor.submit(contar_pares, lote) for lote in lotes]
    resultados = [futuro.result() for futuro in futuros]

total_de_pares = sum(resultados)
print(total_de_pares)  # 5

from concurrent.futures import ThreadPoolExecutor
from threading import Event, Lock


class Reservas:
    def __init__(self, capacidade: int) -> None:
        self._restantes = capacidade
        self._lock = Lock()

    def reservar(self) -> bool:
        # Leitura, decisão e atualização formam uma única seção crítica.
        with self._lock:
            if self._restantes == 0:
                return False
            self._restantes -= 1
            return True

    def vagas_restantes(self) -> int:
        # Esta leitura participa da verificação de uma visão coerente.
        with self._lock:
            return self._restantes


def tentar_reserva(
    reservas: Reservas,
    pronto: Event,
    iniciar: Event,
) -> bool:
    pronto.set()
    if not iniciar.wait(timeout=1):
        raise RuntimeError("O início coordenado não foi liberado")
    return reservas.reservar()


def main() -> None:
    capacidade = 1
    reservas = Reservas(capacidade)
    iniciar = Event()
    prontos = [Event(), Event()]

    with ThreadPoolExecutor(max_workers=2) as executor:
        futuros = [
            executor.submit(tentar_reserva, reservas, pronto, iniciar)
            for pronto in prontos
        ]

        try:
            assert all(pronto.wait(timeout=1) for pronto in prontos), (
                "Nem todos os trabalhadores chegaram ao portão de início"
            )
        finally:
            # Libera quem já estiver esperando, inclusive se a asserção falhar.
            iniciar.set()

        resultados = [futuro.result(timeout=1) for futuro in futuros]

    aceites = sum(resultados)
    recusas = len(resultados) - aceites
    restantes = reservas.vagas_restantes()

    assert aceites == 1
    assert recusas == 1
    assert restantes == capacidade - aceites
    assert aceites <= capacidade

    print(f"Resultados: {resultados}")
    print(f"Aceites: {aceites}; recusas: {recusas}; restantes: {restantes}")


if __name__ == "__main__":
    main()

from concurrent.futures import ThreadPoolExecutor
from threading import Event, Lock


class MesaInsegura:
    def __init__(self, vagas: int) -> None:
        self.vagas = vagas

    def reservar(
        self,
        leitura_feita: Event,
        pode_atualizar: Event,
    ) -> bool:
        vagas_observadas = self.vagas
        leitura_feita.set()

        if not pode_atualizar.wait(timeout=1):
            raise RuntimeError("coordenação da demonstração falhou")

        if vagas_observadas <= 0:
            return False

        self.vagas -= 1
        return True


class MesaSegura:
    def __init__(self, vagas: int) -> None:
        self._vagas = vagas
        self._lock = Lock()

    def reservar(self) -> bool:
        with self._lock:
            if self._vagas <= 0:
                return False
            self._vagas -= 1
            return True

    def devolver_vaga(self) -> None:
        with self._lock:
            self._vagas += 1

    def vagas_disponiveis(self) -> int:
        with self._lock:
            return self._vagas


def demonstrar_corrida() -> None:
    mesa = MesaInsegura(vagas=1)
    leitura_a = Event()
    leitura_b = Event()
    pode_atualizar = Event()

    with ThreadPoolExecutor(max_workers=2) as executor:
        futuro_a = executor.submit(mesa.reservar, leitura_a, pode_atualizar)
        futuro_b = executor.submit(mesa.reservar, leitura_b, pode_atualizar)
        try:
            assert leitura_a.wait(timeout=1), "a primeira leitura não ocorreu"
            assert leitura_b.wait(timeout=1), "a segunda leitura não ocorreu"
        finally:
            # Libera trabalhadores mesmo se uma asserção acima falhar.
            pode_atualizar.set()

        resultados = [futuro_a.result(), futuro_b.result()]

    assert sum(resultados) == 2
    assert mesa.vagas == -1
    print("Corrida controlada:", resultados, "vagas:", mesa.vagas)


def verificar_protecao() -> None:
    mesa = MesaSegura(vagas=1)
    iniciar = Event()

    def tentar_reserva() -> bool:
        if not iniciar.wait(timeout=1):
            raise RuntimeError("início das reservas não foi liberado")
        return mesa.reservar()

    with ThreadPoolExecutor(max_workers=2) as executor:
        futuros = [executor.submit(tentar_reserva) for _ in range(2)]
        iniciar.set()
        resultados = [futuro.result() for futuro in futuros]

    assert sum(resultados) == 1
    assert mesa.vagas_disponiveis() == 0
    print("Versão protegida:", resultados, "vagas:", mesa.vagas_disponiveis())


demonstrar_corrida()
verificar_protecao()