Semáforos n Variáveis compartilhadas são globais n Acesso a variáveis ocorre em procedimentos, mas podem estar espalhados pelo programa n Exige consulta a todo o programa para entender como as variáveis compartilhadas são usadas n A cada novo processo, é preciso verificar se ele usa as variáveis corretamente n Mesma estrutura é usada para exclusão mútua e sincronização de condição

Modularização n ADT – Abstract Data type  Abstração de dados: esconde a representação de dados  Dados são manipulados apenas pelas operações disponibilizadas pelo tipo de dados n Concentra dados e operações em um único lugar n Permite que a implementação seja modificada, desde que a interface e funcionamento continuem os mesmos.

Monitores n Utilizam o coceito de ADT n Processos interagem apenas através de chamadas aos procedimentos do monitor n Modularização abstrai os processos da implementação do procedimento n Permite ignorar como e onde os procedimentos do monitor são usados: o monitor estará correto independentemente do número de processos que o utilizam.

Monitores n Podem ser implementados eficientemente n Exclusão mútua implícita entre procedimentos do monitor n Variáveis de condição são usadas para sincronização de condição n Permite o desenvolvimento por equipes independentes dos processos e monitores n Facilita o desenvolvimento e entendimento dos programas concorrentes

Produtor-Consumidor n monitor Producer_Consumer_Monitor { int B [0..N-1]; int In_Ptr = 0; int Out_Ptr = 0; int Count = 0; Condition Not_Full, Not_Empty; void Append(int I) { while (Count == N) {wait(Not_Full)}; B [In_Ptr] = I; Count = Count + 1; In_Ptr = (In_Ptr + 1) % N; signal(Not_Empty); }

Produtor-Consumidor n void Take(int I) { while (Count == 0) {wait(Not_Empty)}; I = B[Out_Ptr]; Count = Count - 1; Out_Ptr = (Out_Ptr + 1) % N; signal(Not_Full); } }

Produtor-Consumidor n Producer () { int I; while (TRUE) { Produce(I); Append(I); } } n Consumer { int I; while (TRUE) { Take(I); Consume(I); } }

Diferenças n 3 Semáforos  Um para exclusão mútua, e dois (Not_empty e Not_Full) para sincronização n Monitores:  exclusão mútua: implícita entre os procedimentos do monitor  sincronização: através de variáveis de condição

Operações sobre Variáveis de Condição n wait(C)  suspende processo em uma fila FIFO associada a C, e libera a exclusão mútua. n signal(C)  se a fila de C não está vazia, acorda o processo no início da fila, caso contrário não faz nada. n empty(C)  true se a fila de C está vazia

Operações sobre Variáveis de Condição n wait(C,rank)  Semelhante ao wait, mas processos são acordados em ordem crescente de rank n minrank(C)  Retorna o rank do primeiro processo da fila n Signal_all(C)  Acorda todos os processos suspensos em C

Shortest-job-next n monitor ShortestJobNext { BOOL free = TRUE; Condition turn; void request (int time) { if (free) {free = FALSE} else {wait(turn, time)}; } void release () { if (empty(turn)) {free = TRUE;} else {signal(turn);}; }

Revendo o problema dos Leitores e Escritores n Leitores não precisam se excluir mutuamente n Escritores precisam excluir todos os outros processos

Leitores e Escritores n Reader () { while (TRUE) { Start_Read; Read_the_Data; End_Read; } } n Writer () { while (TRUE) { Start_Write; Write_the_Data; End_Write; } }

Monitor n Variáveis de status  Readers  # de leitores lendo  Writing  true quando o processo está escrevendo n Variáveis de condição  OK_to_Read  OK_to_Write

Monitor n Monitor Reader_Writer_Monitor { int Readers = 0; BOOL Writing = False; Condition OK_to_Read, OK_to_Write; n void Start_Read { while (Writing) {wait(OK_to_Read);}; Readers = Readers + 1; } n void End_Read { Readers = Readers - 1; if (Readers==0) {signal(OK_to_Write);}; }

Monitor n void Start_Write { if (Readers > 0 || Writing) {wait(OK_to_Write);}; Writing = True; } n void End_Write { Writing := False; signal(OK_to_Write); signal_all(OK_to_Read); } }

Emulação de semáforos por monitores n monitor Semaphore_Emulation { int S = 0; Condition Not_Zero; procedure P { while (S==0) {wait(Not_Zero);}; S = S - 1; } procedure V { S = S + 1; signal(Not_Zero); } }

Emulação de semáforos por monitores (2) n monitor Semaphore_Emulation { int S = 0; Condition Not_Zero; procedure P { if (S > 0) {S = S – 1;} else {wait(Not_Zero);}; } procedure V { if (empty(Not_Zero) {S = S + 1} else {signal(Not_Zero)}; } }

O Problema do barbeiro que dorme n Semelhante a problemas de escalonamento de disco n Relacionamento cliente-servidor n rendezvous

O Problema do barbeiro que dorme n Barbearia com duas portas (entrada e saída) e algumas cadeiras (espera) n Barbeiro atende um cliente de cada vez n Se faltam clientes, o barbeiro dorme n Se um cliente chega, ele acorda o barbeiro para que corte seu cabelo n Cliente dorme nas cadeiras de espera se o barbeiro está ocupado

O Problema do barbeiro que dorme n Clientes e barbeiros são processos n Barbearia é o monitor n Relação cliente/servidor(barbeiro)

Procedimentos do monitor n get_haircut n get_next_custumer n finished_cut

Leitores e Escritores n Reader () { while (TRUE) { Start_Read; Read_the_Data; End_Read; } } n Writer () { while (TRUE) { Start_Write; Write_the_Data; End_Write; } }