# Aula 30/04

## Voltando ao algoritmo de Bakery

Vamos ver uma maneira de tirar o `for` de dentro da sessão critica.

```
int turn[1:n] = ([n]0)

process CS[i = 1 to n]
    while (true)
        turn[i] = 1
        turn[i] = max(turn[1:n])+1
        for [j = 1 to n such that j != i]
            while (turn[j] != 0 and (turn[i], i) > (turn[j], j))
                sleep

        sessao_critica()

        turn[i] = 0

        Sessao_nao_critica()
```

Porém estre codigo é limitado pelo tamanho do da varival turn, pois quando ela estoura, o codigo quebra.


## Algoritmo de Lamport

A ideia do algoritmo é usar duas *portas* para a entrada na sessão critica.

1. Coloco que quero entrar na primeira porta
2. Se a segunda estiver vazia, coloco eu nela
3. Checo se meu numero continua na primeira

Um algoritmo generalizado é:

```
int gate1 = gate2 = 0

process CS[i:n]

    while (true)
        Sessao_nao_critica()

        p1: gate1 = 1
            want[i] = true
            if (gate2 != 0)
                want[i] = false
                goto p1:
            gate2 = p

            if (gate1 != 1)
                want[i] = false
                for all other process j
                    await want[j] = false

                if (gate2 != 1)
                    goto p1:
                else
                    want[i] = true

                sessao_critica()
                gate2 = 0
                want[i] = false

```