Objetivos

Desenvolver um programa com base no Projeto #1 ou #2 de modo a explorar o conceito de servidores com múltiplas threads. Dentre os objetivos deste projeto destacamos:

Descrição do Projeto

De posse desta Versão Distribuída da Base de Dados, implemente o Algoritmo dos Leitores/Escritores de modo que se vários clientes tiverem acessando a base de dados, a coerência das informações lá contidas é mantida. Ou seja, se vários leitores estão lendo alguma informação na base de dados, não há porque impossibilitar a leitura simultânea, mas se vários clientes estão atualizando a base de dados, incoerências podem aparecer.

Para atender a múltiplas requisições é necessário que servidor crie tantas "threads" ( Alg. de Dekker e Peterson) quanto o número de requisições sendo atendidas. Outra abordagem é deixar que o servidor instancie processos (Suporte à Multiprogramação) no lugar de intanciar várias "threads". Todavia, isto não basta, precisamos garantir a exclusão mútua. Semáforos (Semáforos no Linux) constituem-se num excelente mecanismo para garantir a exclusão mútua.

William Stallings descreve o Problema dos Leitores/Escritores como dados que devem ser compartilhados por vários processos. Entre os processos Leitores/Escritores as seguintes condições devem ser satisfeitas: 1. quaquer número de leitores pode simultaneamente ler os dados; 2. somente um escritor por vez escreve na base de dados; e 3. se um escritor está escrevendo, nenhum leitor pode ler. Parte do que está proposto como problema, está contemplado nas soluções apresentadas pelo autor.

Apresentamos a seguir 02 soluções para o Problema dos Leitores e Escritores utilizando o mecanismo de semáforos. Na primeira, os Leitores tem prioridade, enquanto na segunda os Escritores tem prioridade. Referência: Operating Systems: Internals and Design Principles; William Stallings; Third Edition; Prentice-Hall.

  /* Solution to the Readers/Writers Problem: Readers have Priority */

  program reader_and_writers

  var readcount: integer;
      x, wsem: semaphore (:= 1);

  procedure reader;
  begin
    repeat
      wait(x);
        readcount := readcount + 1;
        if readcount = 1 then wait(wsem);
      signal(x);
      READUNIT;
      wait(x);
        readcount := readcount - 1;
        if readcount = 0 then signal(wsem);
      signal(x);
    forever
  end;

  program writer;
  begin
    repeat
      wait(wsem);
        WRITEUNIT;
      signal(wsem);
    forever
  end;

  begin
    readcount := 0;
    parbegin
      reader; writer;
    parend;
  end.

  /* Solution to the Readers/Writers Problem: Writers have Priority */

  program reader_and_writers

  var readcount, writecount: integer;
      x, y, z, wsem, rsem: semaphore (:= 1);

  procedure reader;
  begin
    repeat
      wait(z)
        wait(rsem);
          wait(x);
            readcount := readcount + 1;
            if readcount = 1 then wait(wsem);
          signal(x);
        signal(rsem);
      signal(z);
      READUNIT;
      wait(x);
        readcount := readcount - 1;
        if readcount = 0 then signal(wsem);
      signal(x);
    forever
  end;

  program writer;
  begin
    repeat
      wait(y);
        writecount := writecount + 1;
        if writecount = 1 then wait(rsem);
      signal(y);
      wait(wsem);
      WRITEUNIT;
      signal(wsem);
      wait(y);
        writecount := writecount - 1;
        if writecount = 0 then signal(rsem);
      signal(y);
    forever
  end;

  begin
    readcount, writecount := 0;
    parbegin
      reader; writer;
    parend;
  end.

Adicionalmente,é provavél que você tenha especificado o protocolo considerando que as primitivas não são confiáveis, ou seja, a possibilidade da mensagem se perder pela rede ou ser corrompida é tão pequena, que basta mensagens do tipo: request/reply. Se a taxa de erros não for tão pequena a ponto de ser deconsiderada, proponha e especifique um protocolo para tratar desses casos.