Problemas Clássicos Envolvendo

Inter-Processos e Algoritmos de Decisão

O Problema dos Leitores e Escritores

Disciplina: Sistemas Operacionais

Professor: Luis Fernando Cozin

Fernando Huescar Aguilar Código: 796886

Jair Marcelino Código: 799186
Matheus Bartholomeu Código: 799448

2010
 O Problema dos Leitores e Escritores
Outros problemas são úteis para modelar processos concorrentes pelo
acesso exclusivo a um numero limitado de recursos, como dispositivos de
Entrada/Saida. O problema dos Leitores e Escritores, modela o acesso a uma base
de dados. Por exemplo, um sistema de reserva e linhas aéreas, com muitos
processos em competição, querendo ler e escrever. É aceitável que múltiplos
processos leiam a base de dados ao mesmo tempo, mas, se um processo estiver
atualizando (escrevendo) na base de dados, nenhum outro processo pode ter
acesso ao banco de dados, nem mesmo os leitores. A questão é: como programar
os leitores e os escritores?

Código: Solução em C
semaphore mutex = 1; //controla acesso a região critica
semaphore db = 1; //controla o acesso a base de dados
int rc = 0; //numero de processos lendo ou querendo ler

void reader(void){
while (TRUE){ //loop infinito
down(&mutex); //obtém acesso exclusivo a região
critica
rc = rc++; //um leitor a mais
if(rc == 1)down(&db); //se este for o primeiro leitor,
bloqueia a base de dados
up(&mutex); //libera acesso exclusivo a região
critica
read_data_base(); //acesso aos dados
down(&mutex); //obtém acesso exclusivo a região
critica
rc = rc--; //um leitor a menos
if(rc==0)p(&db); //se este for o ultimo leitor, libera a
base de dados
up(&mutex); //libera o acesso a região critica
use_data_read(); //utiliza os dados
}
}

void writer(void){
while (TRUE){ //loop infinito
think_up_data(); //região não critica
down(&db); //obtém acesso exclusivo
write_data_base(); //atualiza os dados
up(&db); //libera acesso exclusivo
}
}

A partir dessa solução, para obter o acesso à base de dados, o primeiro

leitor faz um down no semáforo db. Os leitores subseqüentes meramente
incrementam um contador, rc. Conforme saem, os leitores decrescem o contador
de um e o ultimo leitor a sair faz um up no semáforo, permitindo que um eventual
escritor bloqueado entre.

O Código apresentado aqui contém implicitamente uma decisão sutil.

Suponha que, enquanto um leitor esta usando a base de dados, um outro leitor
chegue. Como ter dois leitores ao mesmo tempo não é um problema, o segundo
leitor é admitido. Um terceiro leitor e outros subseqüentes podem também ser
admitidos se chegarem.

Agora imagine que chegue um escritor. O escritor não pode ser

admitido na base de dados, pois escritores devem ter acesso exclusivo. O escritor
é então suspenso. Leitores adicionais chegam. Enquanto houver pelo menos um
leitor ativo, leitores subseqüentes serão admitidos. Como conseqüência dessa
estratégia, enquanto houver um fluxo estável de leitores chegando, todos entrarão
assim que chegarem. O escritor permanecerá suspenso até que nenhum leitor
esteja presente. Se um novo leitor chegar a cada dois segundos, e cada leitor levar
cinco segundos para fazer seu trabalho, o escritor nunca entrará.

Para evitar essa situação, o programa poderia ser escrito de um modo

um pouco diferente: se um leitor chegar quando um escritor estiver esperando, o
leitor será suspenso logo depois do escritor, em vez de ser admitido de imediato.
Dessa maneira, um escritor para terminar, precisa esperar por leitores que estavam
ativos quando ele chegou, mas não por leitores que chegaram depois dele. A
desvantagem dessa solução é que se consegue menos concorrência e, portanto
um desempenho menor.

Resumindo
Simplificando. Trata-se de uma generalização do problema do Buffer
Circular, que tem um único produtor (escritor) e um único consumidor (leitor)
armazenando e recuperando dados.

 No problema dos leitores e escritores, em vez de uma fila circular, os

processos acessam um banco de dados compartilhado;
 Os leitores podem acessar os dados, mas não podem alterá-los;
 Os escritores podem alterar os dados ou acrescentar novos dados.
 Os Leitores acessam o banco em qualquer ordem;
 Muitos leitores podem ler os mesmos dados;

Problemas caso ocorra ao mesmo tempo, um leitor e um escritor.

O leitor solicita a informação no banco de dados compartilhado enquanto o escritor
altera a informação nesta base de dados.

Problema, a informação presente na tela do leitor é diferente da

informação contida na base de dados. Por essa razão não podemos permitir que
um leitor e um escritor acessem simultaneamente o banco. Da mesma forma não
podemos permitir que dois escritores acessem dados simultaneamente.

Uma maneira de corrigir esse problema seria impedindo que leitores

acessem o banco depois que o escritor solicita o acesso, através da aplicação de
algumas metas:
 1 Permitir que um leitor acesse o banco de dados se nenhum escritor
estiver ativo, mas negar o acesso a um leitor se um escritor estiver ativo;
 2 Permitir o acesso de um escritor somente se nenhum leitor ou outros
escritores estiverem ativos.

Aplicando estas metas parecem resolver o problema, no entanto se um

escritor estiver ativo e mais escritores solicitarem acesso, devido a meta 2 um
escritor não conseguirá o acesso.
 Se não existir nenhum processo tanto leitor quanto escritor acessando
o Base de Dados, o acesso é concedido normalmente.

Problema
Se sempre chegarem Processos Leitores e existir pelo menos um
Processo Leitor acessando, o Processo Escritor pode chegar a um problema
denominado Starvation (inanição).
Starvation é a possibilidade de um Processo nunca conseguir acessar a
Base de Dados.

Alternativa

Ter uma condição que exprima a ausência de privações, uma

situação possível em sistemas concorrentes, quando a competição entre processos
deixa algum processo eternamente privado de acessar algum recurso, por os
pedidos dos outros serem sempre atendidos com prioridade.
Uma forma de impedir a ocorrência de privação é impor uma
disciplina de atendimento dos pedidos, baseada numa ordenação segundo a ordem
de chegada.

Condições para uma boa solução do problema

 Um escritor exclui qualquer outro processo.

 Qualquer numero de leitores podem acessar a base de dados
concorrentemente.
 Um fluxo de leitores não deve monopolizar o acesso, se houver um
escritor à espera.
 Um fluxo de escritores não deve monopolizar o acesso, se houver um
escritor à espera.

As duas últimas condições exprimem a ausência de privação, uma

situação possível em sistemas concorrentes, quando a competição entre processos
deixa algum processo eternamente privado de acessar algum recurso, por os
pedidos dos outros serem sempre atendidos com prioridade.
 Bibliografia
SHAY, WA, DURHAN, AM “Sistemas Operracionais” São Paulo Makron Books,
1996

TENEWBAUM, AS. “Sistemas Operacionais Modernos” 2ª Edição São Paulo,

Pearson – Prentice Hall, 2003

http://www.slideshare.net/rafaelov/apresentao-do-artigo-threads-o-problema-dos-
leitores-e-escritores-implementado-em-c
Acessado em 10/06/2010