Aula 5

Prévia do material em texto

CCT0011 – Sistemas Operacionais
Aula 05 – Comunicação entre Processos (1ª parte)
Sistemas Operacionais
Estrutura do conteúdo
 Especificação de concorrência em programas
 Problemas de compartilhamento de recursos
 Exclusão mútua
 Sincronização condicional
Sistemas Operacionais
Aplicações concorrentesIntrodução
É comum processos que trabalham juntos (concorrentes) compartilharem recursos do 
sistema: arquivos, dispositivos de E/S e áreas de memória.
Não importa quais recursos são compartilhados, pois os problemas decorrentes dessa 
interação serão os mesmos.
O compartilhamento de recursos entre processos pode gerar situações indesejáveis, 
capazes até de comprometer o sistema.
A comunicação entre processos de uma aplicação pode ser necessária e alguns 
mecanismos são utilizados para isso.
Sistemas Operacionais
Introdução
Neste caso os processos concorrentes precisam que mecanismos do SO sincronizem suas 
execuções.
Compartilhamento de recursos entre processos pode gerar situações indesejáveis
Os mecanismos que garantem a comunicação entre processos concorrentes e o acesso a 
recursos compartilhados são chamados de mecanismos de sincronização.
No projeto de sistemas operacionais multiprogramáveis , é fundamental a 
implementação de mecanismos de sincronização que garantam sua integridade e 
confiabilidade.
Sistemas Operacionais
Processo
gravador
Processo
leitor
dado
Sincronização
leit
ura
gravação
Buffer
Aplicações Concorrentes
• Da mesma forma, um processo só poderá ler dados armazenados do buffer se existir 
algum dado para ser lido.
• Em ambos os casos, os processos deverão aguardar até que o buffer esteja pronto 
para as operações de gravação ou de leitura.
• Dois processos concorrentes trocam 
informações através de operações de 
gravação e leitura em um buffer. Um 
processo só poderá gravar dados no 
buffer caso ele não esteja cheio.
Sistemas Operacionais
O programa A começa a ser processado e, ao 
encontrar o comando FORK, faz com que seja criado 
um outro processo para a execução do programa B, 
concorrentemente ao A.
O comando JOIN permite que o programa A 
sincroniza-se com B, ou seja, quando o programa A 
encontrar JOIN, só continuará a ser processado após 
o término de B.
Especificação de concorrência
A primeira notação para especificação da concorrência foram os comandos:
 FORK – Inicia a execução de outro programa concorrentemente;
 JOIN – O programa chamador espera o outro programa terminar para 
continuar o processamento.
PROGRAM A;
. PROGRAM B;
. .
FORK B; .
. .
. .
JOIN B; END.
.
END.
Sistemas Operacionais
Especificação de concorrência
O comando PARBEGIN (COBEGIN) especifica que a 
sequência de comandos seja executada 
concorrentemente em uma ordem imprevisível, 
através da criação de um processo (processo1, 
processo2, ...).
O comando PAREND (COEND) define um ponto de 
sincronização, onde o processamento só continuará 
quanto todos os processos criados já tiverem 
terminados suas execuções.
Sistemas Operacionais
X := SQRT (1024) + (35.4 * 0.23) - (302 / 7)
PROGRAM Expressao;
VAR X, Temp1, Temp2, Temp3 : REAL;
BEGIN
PARBEGIN
Temp1 := SQRT (1024);
Temp2 := 35.4 * 0.23;
Temp3 := 302 / 7;
PAREND;
X := Temp1 + Temp2 - Temp3;
WRITELN ('x = ', X);
END.
Especificação de concorrência
Os comandos de atribuição situados 
entre PARBEGIN e PAREND são 
executados concorrentemente 
entre si. 
O cálculo final de X só poderá ser 
realizado quando todas as 
variáveis dentro da estrutura 
tiverem sido calculadas.
Sistemas Operacionais
Comunicação Entre Processos
Processos executando concorrentemente podem ser de dois tipos:
 Independente
• Se não puder afetar ou ser afetado pelos outros processos em execução no 
sistema;
• Qualquer processo que não compartilhe dados com qualquer outro processo é 
independente.
 Cooperativo
• Se puder afetar ou ser afetado por outros processos em execução no sistema;
• Qualquer processo que compartilhe dados com outros processos.
Sistemas Operacionais
Comunicação Entre Processos
Existem dois modelos fundamentais de comunicação entre processos:
 Memória compartilhada
• É estabelecida uma área compartilhada para que os processos possam ler ou 
escrever nessa área.
 Memória distribuída
• A comunicação é toda feita através de troca de mensagens.
Sistemas Operacionais
Problemas de compartilhamento de recursos
Para compreendermos melhor por que a sincronização entre processos é fundamental, 
quando recursos são compartilhados em sistemas multiprogramáveis, vemos alguns 
problemas aplicados a duas situações práticas:
• A alteração de uma variável em memória.
• A alteração de um arquivo compartilhado em disco;
Sistemas Operacionais
Problemas de compartilhamento de recursos
Suponha que dois processos (A e B) estejam executando um comando de atribuição, onde 
o processo A some 1 a variável X, e o processo B diminua 1 da mesma variável 
compartilhada por ambos. Inicialmente vamos considerar que a variável X possua o 
valor 2.
Processo A Processo B
X := X + 1; X := X - 1;
Os comandos de atribuição, em uma linguagem de alto nível, podem ser decompostos 
em comandos mais elementares:
Processo A Processo B
LOAD x,Ra LOAD x,Rb
ADD 1,Ra SUB 1,Rb
STORE Ra,x STORE Rb,x
Sistemas Operacionais
Problemas de compartilhamento de recursos
Processo Comando X Ra Rb 
A LOAD x,Ra 2 2 *
A ADD 1,Ra 2 3 *
B LOAD x,Rb 2 * 2
B SUB 1,Rb 2 * 1
A STORE Ra,x 3 3 *
B STORE Rb,x 1 * 1
• Imaginemos que o processo A carregue o valor 
de X no registrador Ra, some 1 a ele , no 
momento em que vai armazenar o valor em X, 
seja interrompido.
• Neste instante, o processo B inicia sua 
execução, carregando o valor de X em Rb e 
subtraindo 1 dele. 
• O processo A volta a ser processado e atribui o 
valor 3 a X, terminando, assim, sua execução, 
• Finalmente, o processo B é processado e atribui 
o valor 1 a X, sobrepondo o valor anterior.
Sistemas Operacionais
Problemas de compartilhamento de recursos
Suponha um arquivo de contas 
bancárias (Arq_contas), onde cada 
cliente tem seu saldo controlado. 
O programa abaixo, atualiza o saldo de 
um cliente, após um lançamento.
O programa lê o registro do cliente no 
arquivo (Reg_Cliente);
Lê o valor a ser depositado ou retirado 
(Valor_dep_Ret), e
Atualiza o saldo no arquivo de contas.
PROGRAM Conta_Corrente;
READ (Arq_Contas, Reg_Cliente);
READLN (Valor_Dep_Ret);
Reg_Cliente.Saldo := 
Reg_Cliente.Saldo + 
Valor_Dep_Ret;
WRITE (Arq_Contas, Reg_Cliente);
END.
Sistemas Operacionais
Problemas de compartilhamento de recursos
Dois caixas diferentes estão atualizando o 
saldo de um mesmo cliente 
simultaneamente:
• O primeiro caixa lê o registro do cliente 
e soma ao campo Saldo o valor do 
lançamento.
• Antes de gravar o novo saldo no 
arquivo, outro caixa lê o registro do 
mesmo cliente, que está sendo 
atualizado, para realizar outro 
lançamento.
• Independentemente de qual dos caixas 
atualize primeiro o saldo no arquivo, o 
dado gravado estará inconsistente.
Caixa Comando Saldo arquivo Valor dep/ret Saldo memória
1 READ 1.000 * 1.000
1 READLN 1.000 -200 1.000
1 := 1.000 -200 800
2 READ 1.000 * 1.000
2 READLN 1.000 +300 1.000
2 := 1.000 +300 1.300
1 WRITE800 -200 800
2 WRITE 1.300 +300 1.300
Sistemas Operacionais
Problemas de compartilhamento de recursos
Condição de corrida (race conditions)  são situações onde dois ou mais processos estão 
acessando dados compartilhados, e o resultado final do processamento depende de 
quem executa e quando executa.
Analisando os dois exemplos, concluímos que em qualquer situação, onde dois ou mais 
processos tenham acesso a um mesmo recurso compartilhado, devem existir 
mecanismos de controle que evitem esses tipos de problemas.
Encontrar alguma forma de proibir que mais de um processo acesse o dado 
compartilhado ao mesmo tempo, isto é, estabelecer a exclusão mútua de execução.
Soluções.............
Sistemas Operacionais
Exclusão Mútua
A solução mais simples, para evitar os problemas de compartilhamento, é impedir que 
dois ou mais processos acessem um mesmo recurso no mesmo instante.
Enquanto um processo estiver acessando determinado recurso, todos os outros que 
queiram utilizar esse mesmo recurso deverão esperar até que o primeiro processo 
termine o uso.
Essa ideia de exclusividade de acesso é chamada de exclusão mútua.
Sistemas Operacionais
Exclusão Mútua
Região crítica
Protocolos de acesso
BEGIN
.
Entra_Regiao_Critica;
Regiao_Critica;
Sai_Regiao_Critica;
.
.
END.
A exclusão mútua deve apenas afetar os processos 
concorrentes quando um deles estiver fazendo o 
acesso ao recurso compartilhado.
A parte do código do programa onde é feito o acesso 
ao recurso compartilhado é denominado região 
crítica.
Os mecanismos que implementam a exclusão mútua 
utilizam um protocolo de acesso à região crítica.
Toda vez que um processo for executar sua região 
crítica, ele obrigatoriamente executará antes, um 
protocolo de entrada nessa região. 
Da mesma forma que, ao sair, deverá executar um 
protocolo de saída.
Sistemas Operacionais
Região Crítica
Aplicação dos protocolos para dois processos (A e B), manipulando o arquivo contas:
• Sempre que o processo A for atualizar o saldo de um cliente, antes de ler o registro, ele 
deverá garantir o acesso exclusivo através do protocolo de entrada na sua região 
crítica.
• O protocolo indica se já existe ou não algum processo acessando o registro.
• Caso o processo A esteja em sua região crítica e o processo B tente acessar o mesmo 
registro, o protocolo de entrada faz com que ele fique aguardando, até que o processo 
A termine o acesso ao recurso.
• Quando o processo A termina a execução de sua região crítica, deve sinalizar, aos 
outros processos concorrentes, que terminou o acesso ao recurso.
• Isso é realizado através do protocolo de saída que informa aos outros processos que 
podem tentam acessar o recurso com sucesso.
Sistemas Operacionais
Região Crítica
Processos com diferença nos tempos de processamento podem introduzir problemas na 
exclusão mútua.
Para garantir a implementação da exclusão mútua os processos envolvidos devem fazer 
acesso aos recursos de forma sincronizada.
Diversas soluções foram desenvolvidas com este propósito; porém, além da garantia da 
exclusão mútua, duas situações indesejadas também devem ser evitadas.
Sistemas Operacionais
Starvation
Starvation ou espera indefinida é a primeira situação indesejada, onde um processo 
nunca consegue executar sua região crítica, e consequentemente, acessar o recurso 
compartilhado.
• Ocorre quando dois ou mais processos esperam por um mesmo recurso alocado. 
Caso o sistema escolha o processo aleatoriamente quando o recurso é liberado, um 
processo pode nunca ser escolhido.
• Quando um processo tem baixa prioridade também pode não ser escolhido nunca.
• Filas FIFO eliminam esse problema.
Sistemas Operacionais
Starvation
Exemplo1: 
No momento em que um recurso é liberado, o sistema operacional possui um critério 
para selecionar, dentre os processos que aguardam pelo uso do recurso, qual será o 
escolhido. Em função deste critério, o starvation pode ocorrer.
Exemplo 2:
Outra situação indesejada é aquela que um processo fora da sua região crítica impede 
que outros processos entrem nas suas próprias regiões críticas.
No caso desta situação ocorrer, um recurso estaria livre, porém alocado a um processo.
Neste caso vários processos estariam sendo impedidos de utilizar o recurso, reduzindo o 
grau de compartilhamento.
Sistemas Operacionais
Exclusão Mútua – Soluções de Hardware
Desabilitar interrupções
BEGIN
.
.
Desabilita_Interrupcoes;
Regiao_Critica;
Habilita_Interrupcoes;
.
.
END
O processo desabilita todas as interrupções antes 
de entrar na sua região crítica, e as reabilita após 
deixar a região crítica.
Problemas: 
• Se o processo não habilitar as interrupções 
ao sair da região crítica, o sistema pode ficar 
comprometido.
• Multiprogramação seriamente 
comprometida.
• Ineficiente em sistemas com múltiplos 
processadores.
Sistemas Operacionais
Exclusão Mútua – Soluções de Hardware
Instrução especial de máquina, que existe em muitos processadores, e permite ler uma 
variável, armazenar seu conteúdo em outra área e atribuir um novo valor à mesma 
variável;
Esta instrução é chamada test-and-set (test-and-set (X,Y)).
Quando executada o valor lógico da variável Y é copiado para X, sendo atribuído à 
variável Y o valor lógico verdadeiro.
• A instrução utiliza uma variável lógica global denominada bloqueio.
• Enquanto a variável bloqueio for falsa qualquer processo pode acessar o recurso de 
forma exclusiva alterando o valor para verdadeiro.
• O processo retorna o valor da variável para falso assim que termina o acesso.
Sistemas Operacionais
Exclusão Mútua – Soluções de Hardware
• Executada sem interrupção e é uma instrução invisível.
• Assim, dois processos não podem manipular uma variável compartilhada ao 
mesmo tempo (exclusão mútua).
O uso de instrução de máquina facilita a implementação da exclusão mútua e o uso em 
arquiteturas com múltiplos processadores sem maiores problemas.
Uma grande desvantagem é a possibilidade de ocorrer starvation, já que a seleção do 
processo que fará uso do recurso é arbitrária.
Sistemas Operacionais
Instrução test_and_set
PROGRAM Test_And_Set;
VAR Bloqueio : BOOLEAN;
PROCEDURE Processo_A;
VAR Pode_A : BOOLEAN;
BEGIN
REPEAT
Pode_A := True;
WHILE (Pode_A) DO 
Test_ans_set (Pode_A, Bloqueio);
Regiao_Critica_A;
Bloqueio := False;
until False;
END;
PROCEDURE Processo_B;
BEGIN
REPEAT
Pode_B := True;
WHILE (Pode_B) DO 
Test_ans_set (Pode_B, Bloqueio);
Regiao_Critica_B;
Bloqueio := False;
until False;
END;
BEGIN
Bloqueio := False;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
Processo Instrução Pode_A Pode_B Bloqueio
A REPEAT * * False
B REPEAT * * False
A Pode_A:= True true * False
B Pode_B:= True * True False
B while * True False
B test_and_set * False true 
A while true * true
A test_and_set true * true 
B regiao_critica * False true 
A while true * true 
B bloqueio := false * False false
B until false * False false
B REPEAT * False false 
Sistemas Operacionais
Exclusão Mútua – Soluções de Software
Fatores para a solução de problemas de sincronização:
• O número de processadores e o tempo de execução dos processos concorrentes 
devem ser irrelevantes;
• Um processo, fora de sua região crítica, não pode impedir que outros processos 
entrem em suas próprias regiões críticas;
• Um processo não pode permanecer indefinidamente esperando para entrar em sua 
região crítica.
Soluções:
• Primeiro,segundo, terceiro e quarto algoritmos:
• Algoritmo de Dekker
• Algoritmo de Peterson
• Algoritmo para exclusão mútua entre N processos
Sistemas Operacionais
Primeiro Algoritmo
Este algoritmo apresenta uma solução para a exclusão mútua entre dois processos, onde 
um mecanismo de controle alterna a execução das regiões críticas.
Limitações: 
• O acesso ao recurso compartilhado só pode ser realizado por dois processos 
apenas e sempre de maneira alternada;
• O mecanismo utiliza uma variável de bloqueio;
• Outro problema é que caso ocorra algum problema com um dos processos, de 
forma que a variável de bloqueio não seja alterada, o outro processo permanecerá 
indefinidamente bloqueado, aguardando o acesso ao recurso.
Sistemas Operacionais
PROGRAM Algoritmo1;
VAR vez : CHAR;
PROCEDURE Processo_A;
BEGIN
REPEAT
WHILE (vez = “B”) DO (* Não faz 
nada*);
Região_Critica_A;
Vez := “B”;
Processamento_A;
until False;
END;
PROCEDURE Processo_B;
BEGIN
REPEAT
WHILE (vez = “A”) DO (* Não faz 
nada*);
Região_Critica_B;
Vez := “A”;
Processamento_BA;
until False;
END;
BEGIN
vez := A;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
Processo_A Processo_B vez
While(vez = “B”) While(vez = “A” A 
Regiao_critica_A While(vez = “A”) A 
vez := “B” ) While(vez = “A” B 
Processamento_A Regiao_critica_B B 
Processamento_A vez := “A” A
Processamento_A Processamento_B A 
Primeiro Algoritmo
Sistemas Operacionais
Segundo Algoritmo
Neste caso é utilizada uma variável distinta para cada processo, com o objetivo de 
resolver a limitação do primeiro algoritmo. 
Soluções e problemas:
• Antes de entrar em sua região crítica um processo deve testar a variável do outro 
processo;
• O uso do recurso não e necessariamente alternado;
• Caso ocorra algum problema com um dos processo, fora da região crítica, o outro 
processo não ficará bloqueado;
• Caso um processo tenha um problema dentro da sua região crítica ou antes de 
alterar a variável, o outro processo permanecerá indefinidamente bloqueado;
• Outro problema neste caso é que a exclusão mútua, nem sempre é garantida o 
que torna a solução pior que a anterior;
Sistemas Operacionais
PROGRAM Algoritmo2;
VAR CA, CB : BOOLEAN;
PROCEDURE Processo_A;
BEGIN
REPEAT
WHILE (CB) DO (* Não faz nada*);
CA := true;
Região_Critica_A;
CA := false;
Processamento_A;
until False;
END;
PROCEDURE Processo_B;
BEGIN
REPEAT
WHILE (CA) DO (* Não faz nada*);
CB := true;
Região_Critica_B;
CB := false;
Processamento_B;
until False;
END;
BEGIN
CA:= false; 
CB := false;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
Processo_A Processo_B CA CB
While(CB) While(CB) false false 
CA := true CB :+ true true true
Região_critica_A Regiao_critica_B true true
Segundo Algoritmo
Sistemas Operacionais
Terceiro Algoritmo
O algoritmo tenta solucionar o problema apresentado no segundo, colocando a instrução 
de atribuição das variáveis CA e CB antes do loop de teste.
Soluções e problemas:
• Esta alteração resulta na garantia da exclusão mútua, porém introduz um novo 
problema, é a possibilidade de bloqueio indefinido de ambos os processos.
• Se os dois processos alterarem as variáveis CA e CB antes da execução da instrução 
WHILE, nenhum dos dois poderá entrar em sua região crítica, como se o recurso já 
estivesse alocado pelo outro processo.
Sistemas Operacionais
PROGRAM Algoritmo3;
VAR CA, CB : BOOLEAN;
PROCEDURE Processo_A;
BEGIN
REPEAT
CA := true;
WHILE (CB) DO (* Não faz 
nada*);
Região_Critica_A;
CA := false;
Processamento_A;
until False;
END;
PROCEDURE Processo_B;
BEGIN
REPEAT
CB := true; 
WHILE (CA) DO (* Não faz 
nada*);
Região_Critica_B;
CB := false;
Processamento_B;
until False;
END;
BEGIN
CA:= false; 
CB := false;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
Processo_A Processo_B CA CB
While(CB) While(CB) false false 
CA := true CB :+ true true true
Região_critica_A Regiao_critica_B true true
Terceiro Algoritmo
Sistemas Operacionais
Quarto Algoritmo
Esta solução garante a exclusão mútua e não gerar o bloqueio simultâneo dos processos, 
pois permite que a alteração do estado da variável seja revertido, mas uma nova 
situação indesejada pode ocorrer eventualmente.
Soluções e problemas:
• No caso dos tempos aleatórios serem próximos e a concorrência gerar uma 
situação onde os dois processos alterem as variáveis CA e CB para falso antes do 
término do loop, nenhum dos dois processos conseguirá executar sua região 
crítica. 
• Mesmo com esta situação não sendo permanente, pode gerar alguns problemas.
Sistemas Operacionais
PROGRAM Algoritmo4;
VAR CA, CB : BOOLEAN;
PROCEDURE Processo_A;
BEGIN
REPEAT
CA := true;
WHILE (CB) DO (* Não faz nada*);
BEGIN 
CA := false
(pequeno intervalo de tempo aleatório)
CA := true
END;
Região_Critica_A;
CA := false;
until False;
END;
PROCEDURE Processo_B;
BEGIN
REPEAT
CB := true; 
WHILE (CA) DO (* Não faz nada*);
BEGIN 
CB := false
(pequeno intervalo de tempo aleatório)
CB := true
END;
Região_Critica_B;
CB := false; 
until False;
END;
BEGIN
CA:= false; 
CB := false;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
Quarto Algoritmo
Sistemas Operacionais
Algoritmo de Dekker
Primeira solução de software que garantiu a exclusão mútua entre dois processos sem a 
ocorrência de outros problemas.
Foi proposta pelo matemático holandês T. Dekker com base no primeiro e no quarto 
algoritmos, porém possui uma solução bastante complexa. 
Sistemas Operacionais
Algoritmo de Peterson
Antes de acessar a região crítica, o processo sinaliza esse desejo através da variável de 
condição, porém o processo cede o uso do recurso ao outro processo, indicado pela 
variável Vez. 
Em seguida, o processo executa o comando WHILE como protocolo de entrada da região 
crítica.
Neste caso, além da garantia da exclusão mútua, o bloqueio indefinido de um dos 
processos no loop nunca ocorrerá, já que a variável Vez sempre permitirá a 
continuidade da execução de um dos processos. 
Sistemas Operacionais
PROGRAM Algoritmo_peterson
VAR CA, CB : BOOLEAN;
vez : CHAR;
PROCEDURE Processo_A;
BEGIN
REPEAT
CA := true;
Vez := `B`; 
WHILE (CB and Vez = `B`) DO (* Não faz 
nada*);
Região_Critica_A;
CA := false;
processamento_A; 
until False;
END;
PROCEDURE Processo_B;
BEGIN
REPEAT
CB := true;
Vez := `A`; 
WHILE (CA and Vez = `A`) DO (* Não faz 
nada*);
Região_Critica_B;
CB := false; 
Processamento_B;
until False;
END;
BEGIN
CA := false; 
CB := false;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
Algoritmo de Peterson
Sistemas Operacionais
Exclusão mútua entre N Processos
Todas as soluções apresentadas para concorrência entre N processos implementam a 
exclusão mútua. Mas a espera ocupada (busy wait) gera uma deficiência, já que o 
processo que não consegue entrar em sua região crítica fica executando em looping
(testando a condição), consumindo tempo de processador desnecessariamente e 
pode comprometer o desempenho do sistema.
Uma solução para o problema foi introduzida com o mecanismo que coloca o processo 
que não consegue entrar em sua região crítica em estado de espera.
Estes mecanismos são conhecidos como semáforos e monitores.
Sistemas Operacionais
Processo
gravador
Processoleitor
dado
Sincronização
leit
ura
gravação
Buffer
Sincronização Condicional
Sincronização condicional é uma situação onde o acesso ao recurso compartilhado exige a 
sincronização de processos vinculada a uma condição de acesso.
Um recurso pode não se encontrar pronto para uso devido a uma condição específica. 
Neste caso, o processo que deseja acessá-lo deverá permanecer bloqueado até que o 
recurso fique disponível.
Um exemplo clássico desse tipo de sincronização é a comunicação entre dois processos 
através de operações de gravação e leitura em um buffer (processos produtor / 
consumidor ou buffer limitado).
Sistemas Operacionais
Problema do produtor/consumidor ou do buffer limitado.
O recurso compartilhado é um buffer, definido no algoritmo com o tamanho TAMBuf e 
sendo controlado pela variável Cont. 
Sempre que a variável Cont for igual a 0, significa que o buffer está vazio e o processo 
Consumidor deve permanecer aguardando até que se grave um dado. 
Da mesma forma, quando a variável Cont for igual a TamBuf, significa que o buffer está 
cheio e o processo Produtor deve aguardar a leitura de um novo dado.
Apesar do algoritmo resolver a questão da sincronização condicional, o problema da 
espera ocupada também se faz presente, sendo somente solucionado pelos 
mecanismos de sincronização semáforo e monitores
Sistemas Operacionais
Program Produtor_consumidor_1;
CONST Tambuf = ( * Tamanho Qualquer*);
Type Tipo_Dado = ( * Tipo qualquer *);
Var Buffer : ARRAY [ 1..TamBuf] OF Tipo_dado;
Dado_1 : Tipo_dado;
Dado_2 : tipo_daod;
Cont : 0 …. TamBuf;
PROCEDURE Produtor;
BEGIN
REPEAT
Produz_Dado (Dado);
WHILE (Cont = TamBuf) DO (* Nao faz nada *);
Grava_Buffer (Dado, Cont);
UNTIL False;
END;
PROCEDURE Consumidor;
BEGIN
REPEAT
WHILE (Cont = 0) DO (* Nao faz nada *);
Le_Buffer (Dado);
Consome_Dado (Dado, Cont);
UNTIL False;
END;
BEGIN
Cont := 0;
PARBEGIN
Produto;
Consumidor;
PAREND;
END.
Problema do produtor/consumidor ou do buffer limitado.
Sistemas Operacionais
Reflexão e Dúvidas