/* Respostas fornecidas por um aluno da turma. Não foram corrigidas. */

1 – Para thr_0

Para que a thr_0 entre na região crítica, a seguinte condição deve ser
verdadeira: (Ultimo == 1 || Interesse[1] == False) e sabemos que,
neste instante

  i)   Interesse[0] == True;
  ii)  Se Ultimo == 1, Interesse[1] = True;
  iii) Se Interesse[1] = True, Ultimo == 1 ou Ultimo == 0

Ou seja, se Ultimo == 1, temos que a thr_0 entra na região crítica e a
thr_1 fica travada pois (Ultimo == 1 && Interesse[0] == True)

Se Interesse[1] == True e Ultimo == 0, existem dois casos

  a) Thr_1 já executou a linha 3: Neste caso a Thr_1 entra na região
  crítica e Thr_0 fica travada

  b)Thr_1 ainda vai executar a linha 3: Neste caso a Thr_0 fica
  travada até que a Thr_1 execute a linha 3, então Thr_0 entra na
  região crítica e Thr_1 fica travada

E para que a thr_1 entre na região crítica, a seguinte condição deve
ser verdadeira: (Ultimo == 0 || Interesse[0] == False) e sabemos que,
neste instante

i) Interesse[1] == True

Se Ultimo == 0, interesse [0] pode ser false ou true. Em ambos os
casos, a thr_0 fica travada.  Se interesse[0] == False, existem os
seguintes casos

  a) Ultimo == 0. Então a thr_0 ainda executará a linha 3. Thr_1 entra e thr_0 fica travada
  b) Ultimo == 1.
     a.Se thr_0 já executou a linha 2, a thr_1 fica travada e a thr_0 passa

     b.Se a thr_0 ainda não executou a linha 2, a thr_1 fica travada
     até que as thr_0 execute, então a thr_1 entrará e a thr_0 ficará
     travada.

O algortimo Garante Exclusão Mutua.

2 –  a) Não, pois quando uma thread sai da região crítica, coloca 
       “vez =-1” deixando qualquer outra thread entrar.

     b) Não, pois duas threads podem ver o valor de vez como -1 ao
        mesmo tempo
    

3 – O erro causado é um Dead Lock. Duas threads ficam travadas na
primeira espera ocupada. Segue o escalonamento

A thread 0 executa até o if(j != i) para j = 0 e perde o escalonador

A thread 1 executa até o while(escolhendo[j]) para j = 0. Como
escolhendo [j] == true, a thread 1 fica travada.

A thread 0 executa o if(num[j] > max_i) que retorna falso, depois
executa o for, novamente, para j = 1, e entra no while(escolhendo[j])
para j = 1. E também fica travada.

Dead Lock

4 – 
int proximo()
{
pthread_mutex_lock(&lock_n);/*Garante exclusão mutual para acessar a variável n*/
if(n != NMAX)
n++;
pthread_mutex_unlock(&lock_n);
return n;
}

5 – 

a)Sim, pois a variável ne está protegida por um mutex. Um escrito só
poderá entrar na área de escrita quando esta variável possuir valor 0
e o mutex garante que somente uma thread verá este valor e altera-lo,
por vez.

b)Sim. O mutex apenas restringe o acesso a variável nl. Um leitor pode
pegar o lock, alterar o valor de nl e entrar na Leitura, antes que
este saia da leitura, outro leitor pode fazer o mesmo.

c)Sim. Nada garante que a “vez” será passada de um escritor para um
leitor. Logo após um escritor ter saído a região de escrita, ele mesmo
(ou outro escritor) pode conseguir entrar novamente e todos os
leitores ficarem travados no primeiro lock.

d)Sim. Do mesmo jeito que em c), nada garante que os leitores não
terão a “sorte” de sempre pegar o escalonador e nenhum escritor
nunca ter a chance de escrever