Apresentação do artigo THREADS: O PROBLEMA DOS LEITORES E ESCRITORES IMPLEMENTADO EM C#
- 1. Threads: O problema dos Leitores e Escritores Implementado em C# Autores: Daniel Ramon Silva Pinheiro Danilo Santos Souza Rafael Oliveira Vasconcelos Orientadora: Maria de Fátima A. S. Colaço
- 2. Threads É uma forma de um processo dividir-se em duas ou mais tarefas que podem ser executadas simultaneamente Nos hardwares equipados com múltiplos núcleos, as linhas de execução de uma thread, podem ser executadas paralelamente, Já nos hardwares com um único núcleo, cada linha de execução é processada de forma aparentemente simultânea. Neste caso a mudança entre uma linha e outra é feita de forma tão rápida que para o usuário isso está acontecendo paralelamente.
- 3. Threads e Processos – Diferenças Módulos executáveis de um processo Um módulo executável é um conjunto de instruções de um programa que devem ser seguidos para a conclusão do mesmo. Processos são módulos separados e carregáveis Threads não são carregados . Threads são iniciados dentro de um processo (Pai). O processo Pai pode iniciar várias threads ao mesmo tempo.
- 4. Threads: O Universo dos modelos de processos Existem 2 conceitos para os modelos: Primeiro: Modo de ver um processo: Espaço de endereçamento (código e os dados de programa). Alguns recursos alocados (arquivos abertos, processos filhos). Objetivo: Agrupar todos eles em forma de processos para facilitar o gerenciamento dos recursos.
- 5. Threads: O Universo dos modelos de processos Segundo: Thread de execução (Thread): Contador de programa (controla qual instrução da thread deverá ser executada em seguida pelo núcleo) Registradores (com as variáveis de trabalho atuais) Pilha estruturada pelo conjunto de procedimentos chamados, mas ainda não concluídos (informa o histórico da execução).
- 6. Threads e Processos – Diferenças Os dois conceitos citados (Processo e Thread de execução) são importantes, pois delimitam os conceitos entre threads e processos, que apesar de semelhantes, são conceitos diferentes. A característica que os threads acrescentam ao conceito de processos é a permissão de múltiplas execuções ocorrerem em um mesmo processo de forma independente uma das outras.
- 7. Threads: O Universo dos modelos de processos Importância dos modelos (Processo e Thread de execução): Delimitam os conceitos entre threads e processos, que apesar de semelhantes, são conceitos diferentes. A característica que os threads acrescentam ao conceito de processos é a permissão de múltiplas execuções ocorrerem em um mesmo processo de forma independente uma das outras.
- 8. Threads: Sistemas monothread e multithread Sistemas monothread : Sistemas que suportam apenas uma única thread em execução por vez. Sistemas multithread : Sistemas que suportam mais de uma por vez. Questão: Qual a diferença de ter várias threads sendo executadas em um único processo (multithread), e vários processos sendo executados em um computador?
- 9. Threads: O Universo dos modelos de processos Resposta: Nos Sistemas multithread várias threads estão compartilhando um mesmo espaço de endereçamento na memória, assim como os recursos alocados pelo processo criador da thread. Já nos Sistemas monothread os processos compartilham um espaço físico de memória.
- 10. Threads: Tipos (Usuário e Núcleo) Thread de usuário: Todos os pacotes e controles de threads estão no espaço do usuário. O núcleo não sabe que existem essas threads. As threads serão tratadas de forma simples (monothread). Mesmo que existam vários núcleos (multiprocessamento), somente os processos é que serão executados paralelamente e não as threads. Para o núcleo será apenas mais uma linha de execução do processo.
- 11. Threads: Tipos (Usuário e Núcleo) Thread de usuário: Vantagem Principal: Versatilidade, pois elas funcionam tanto em sistemas que suportem ou não o uso de threads Implementação interna ao processo criador da thread. Sistema operacional não irá interferir nesta criação, desta forma o sistema executará a thread como se fosse apenas mais uma linha de execução do processo.
- 12. Threads: Tipos (Usuário e Núcleo) Thread de núcleo: Grande vantagem: Caso uma thread seja bloqueada, as outras threads que forem geradas pelo mesmo processo poderão dar continuidade às suas linhas de execução, sem a necessidade da thread bloqueada concluir suas linhas de execução. O núcleo sabe da existência das threads O processo não precisará de tabela para gerenciar as threads, o núcleo se encarregará de tudo, os processos apenas realizam chamadas ao núcleo para a manipulação de suas threads.
- 13. Threads: Tipos (Usuário e Núcleo) Thread de núcleo: Chamadas ao sistema possuem um custo maior se comparadas com as chamadas que um sistema de threads de usuário realiza. Sistemas utilizam-se da ‘reciclagem’ de threads, desta forma, quando uma thread é destruída, ela é apenas marcada como não executável, sem afetar sua estrutura. Conseqüência: A criação de uma nova thread será mais rápida, com sua estrutura já montada, basta apenas a atualização de suas informações.
- 14. Threads: Comunicação entre as Threads Com freqüência as threads precisam trocar informações entre si para continuar suas linhas de execução. Como elas compartilham um espaço de endereçamento comum isso torna-se um pouco mais fácil, entretanto ainda é necessário um controle para evitar embaraços entre elas. Esses embaraços geralmente ocorrem quando elas acessam uma variável compartilhada ao mesmo tempo, ou seja, dentro de uma região crítica.
- 15. Threads: Comunicação entre as Threads Região Crítica: Região de memória compartilhada que acessa um recurso que está compartilhado e que não pode ser acessado concorrentemente por mais de uma linha de execução Como o próprio nome já diz, por ser uma área crítica necessita de cuidados para que não hajam problemas futuros devido à má utilização da mesma.
- 16. Threads: Comunicação entre as Threads Região Crítica: Condição de disputa: Conjunto de recursos que deve ser compartilhado entre processos no qual, em um mesmo intervalo tempo, dois ou mais processos tentem alocar uma mesma parte de um mesmo recurso para poder utilizá-lo. Nesta hora que ocorre o problema do controle de disputa.
- 17. Threads: Comunicação entre as Threads Região Crítica: Condição de disputa: Necessidade de encontrar uma forma de bloquear que outros processos usem uma área compartilhada que esteja sendo usada até que ela seja liberada pelo processo que a esteja utilizando. A essa solução denomina-se exclusão mútua.
- 18. Threads: Comunicação entre as Threads Exclusão Mútua: Solução encontrada para evitar que dois ou mais processos ou threads tenham acesso simultaneamente a alguma região crítica de algum recurso que esteja compartilhado. Para que a solução seja válida, devem ser satisfeitas quatro condições para que os processos e threads concorrentes à mesma região crítica sejam executados de forma eficiente e corretamente.
- 19. Threads: Comunicação entre as Threads Exclusão Mútua (As Quatro Condições): Nunca dois processos podem estar simultaneamente em suas regiões críticas; Nada pode ser afirmado sobre a velocidade ou sobre o número de CPUs; Nenhum processo executando fora de sua região crítica pode bloquear outros processos; Nenhum processo deve esperar eternamente para entrar em sua região crítica;
- 20. Threads: Problemas com o uso de threads O uso de threads acarreta alguns problemas como: Os de acesso à região crítica Dificuldade de implementação Dificuldade de depuração do código Deadlock e o Starvation
- 21. Threads: Problemas com o uso de threads Deadlock: Ocorre quando há um impasse e dois ou mais processos ou threads ficam impedidos de continuar suas execuções, ou seja, ficam bloqueados para sempre. Starvation: Ocorre quando um processo ou thread nunca é executado, pois processos ou threads de maior importância sempre tomam a posse do núcleo fazendo com que os de menores prioridades nunca sejam executados.
- 22. O Problema dos Leitores e Escritores Modela o acesso a uma Base de Dados. Ocorre em Processos Concorrentes. Processos Leitores somente lêem a Região Crítica. Processos Escritores alteram a Região Crítica Acesso simultâneo para Processos Leitores pelo fato de não alterarem a Região Crítica. Acesso Exclusivo para Processo Escritor pelo fato de alterar a Região Crítica. Para melhor entendimento a seguir, considere a Base de Dados como Região Crítica.
- 23. O Problema dos Leitores e Escritores Vários Processos visando a mesma Base de Dados. Base de Dados PL PL PL PE PL – Processos Leitores PE – Processos Escritores Esperando Acesso a Base de Dados Acessando a Base de Dados 1 2 4 3
- 24. O Problema dos Leitores e Escritores Enquanto existir pelo menos um Processo Leitor acessando a Base de Dados, o acesso para a chegada de novos Processos Leitores será concedido. Base de Dados PL PL PL Base de Dados PL PL PL 1 2 4 PL PL PL 1 2 4 6 9 7 PL – Processos Leitores PE – Processos Escritores Esperando Acesso a Base de Dados Acessando a Base de Dados
- 25. O Problema dos Leitores e Escritores Enquanto existir pelo menos um Processo Leitor acessando a Base de Dados e existir Processo Escritor em espera, a chegada de Processos Leitores para acesso será concedido e o Processo Escritor continuará esperando pelo acesso. Base de Dados PL PL Base de Dados PL PL PL 1 2 PL PL PE 1 2 4 6 9 7 PE 4 PL – Processos Leitores PE – Processos Escritores Esperando Acesso a Base de Dados Acessando a Base de Dados
- 26. O Problema dos Leitores e Escritores Se sempre chegarem Processos Leitores e existir pelo menos um Processo Leitor acessando, o Processo Escritor pode chegar a um problema denominado Starvation, que é a possibilidade do Processo Escritor nunca acessar a Base de Dados pelo fato de sempre estarem chegando Processos Leitores.
- 27. O Problema dos Leitores e Escritores Se não existir nenhum Processo tanto Leitor quanto Escritor acessando a Base de Dados, o acesso é concedido normalmente. Base de Dados Base de Dados PE 4 PL – Processos Leitores PE – Processos Escritores Esperando Acesso a Base de Dados Acessando a Base de Dados
- 28. O Problema dos Leitores e Escritores Processo Escritor faz com que outros Processos esperem pelo acesso. Base de Dados PL PL PE PE 1 2 4 3 PL – Processos Leitores PE – Processos Escritores Esperando Acesso a Base de Dados Acessando a Base de Dados
- 29. O Problema dos Leitores e Escritores Pseudocódigo abordando solução semaphore mutex = 1; // controla acesso a região critica semaphore db = 1; // controla acesso a base de dados int rc = 0; // número de processos lendo ou querendo ler void writer(void) { while (TRUE) { // repete para sempre think_up_data(); // região não critica down(&db); // obtém acesso exclusivo write_data_base(); // atualiza os dados up(&db); // libera o acesso exclusivo } } Variáveis Procedimento do Escritor
- 30. O Problema dos Leitores e Escritores void reader(void) { while(TRUE) { // repete para sempre down(&mutex); // obtém acesso exclusivo a região critica rc = rc + 1; // um leitor a mais agora if (rc == 1) down(&db); //se este for o primeiro leitor bloqueia a base de dados up(&mutex) // libera o acesso a região critica read_data_base(); //acesso aos dados down(&mutex); // obtém acesso exclusivo a região critica rc = rc -1; // menos um leitor if (rc == 0) up(&db); // se este for o último leitor libera a base de dados up(&mutex) // libera o acesso a região critica use_data_read(); // utiliza o dado } } Procedimento do Leitor
- 31. O Problema dos Leitores e Escritores Vantagens Evita Espera Ocupada. Melhor uso da Multiprogramação. Desvantagem Pode ocasionar Starvation.
- 32. Threads no C# O C# provê vários recursos para utilização de threads Iniciar threads Bloqueio simples Mutex, semáforo Monitores Prioridade Manipulação de estados Uso do namespace System.Threading
- 33. Threads no C#: Criando e Iniciando É bastante simples criar e iniciar uma thread Basta criar uma variável do tipo Thread e passar no construtor o método que será executado ThreadStart delegado = new Thread Start(metodo); Thread t = new Thread(delegado;) Ou Thread t = new Thread( ThreadStart(metodo) ); Iniciar a thread é bastantes intuitivo t.Start();
- 34. Threads no C#: Exemplo Olá Mundo class Ola_Mundo { static void Main() { Thread t = new Thread(new ThreadStart(Imprime)); t.Start(); } static void Imprime() { Console.WriteLine("Ola Mundo!"); } }
- 35. Threads no C#: Sincronização A forma mais simples de sincronizar threads é utilizando o método Join Este método faz o bloqueio do programa até que a thread seja executada por completo, sendo então liberado para prosseguir com as demais instruções. Garante que o fluxo de execução só prosseguirá quando a thread terminar sua execução. Esta é uma forma bastante simples da manter a sincronização entre threads, porém anula a execução paralela, principal motivo para o uso de threads.
- 36. Threads no C#: Método Join class Ola_Mundo { static void Main() { Thread t = new Thread(new ThreadStart(Imprime)); t.Start(); t.Join(); Console.WriteLine("Fim do programa."); } static void Imprime() { Console.WriteLine("Ola Mundo!"); } }
- 37. Threads no C#: Bloqueio Lock É a formais de bloqueio mais simples e permite obter a posse de um objeto, bloqueando um bloco de código Evita a condição de corrida e garante a exclusão mútua Caso outra thread tente realizar o bloqueio de um objeto que se encontra bloqueado, a thread será bloqueada pelo sistema operacional e só poderá continuar quando o objetivo for liberado Por ser a forma mais simples de realizar um bloqueio, também é mais rápida.
- 38. Threads no C#: Bloqueio Lock lock (contador) { contador++; Console.WriteLine(contador); }
- 39. Threads no C#: Classe Mutex A classe mutex funciona de forma parecida com o bloqueio lock Por não realizar o bloqueio por blocos de código, permite que tanto o bloqueio como o desbloqueio seja realizado em diferentes regiões do código com uso dos métodos WaitOne e ReleaseMutex Garante a exclusão mútua de uma região crítica A tentativa de bloqueio de um objeto já bloqueado é análoga a forma anterior
- 40. Threads no C#: Classe Mutex mutex.WaitOne(); //bloqueio realizado contador++; Console.WriteLine(contador); mutex.ReleaseMutex(); //recurso liberado
- 41. Threads no C#: Classe Semaphore É uma extensão da classe mutex Como principais características permite que um ou mais processos entrem na região crítica e que o bloqueio realizado por uma thread possa ser desfeito por outra thread, recurso que pode ser útil em determinados problemas, como no problema dos leitores e escritores. Na inicialização deve ser informado o valor máximo e inicial do semáforo Caso o semáforo seja inicializado com valor 1, tem o mesmo funcionamento do mutex
- 42. Threads no C#: Classe Semaphore semaforo.WaitOne(); contador++; Console.WriteLine(contador); semaforo.Release();
- 43. Threads no C#: Classe Monitor O C# oferece ainda a classe Monitor que provê outras funcionalidades como: Sinalizar e esperar por uma sinalização de outra thread Pulse ou PulseAll e Enter Outro recurso interessante é o TryEnter que como o próprio nome diz, tenta obter o acesso ao objeto, caso não seja possível retorna o valor false O método Enter funciona de maneira semelhante aos já mencionados É 33 vezes mais rápida que a classe Mutex
- 44. Threads no C#: Outros recursos Nomear a thread Atribuir prioridade às threads Lowest , BelowNormal , Normal , AboveNormal e Highest Indicar se a thread deve ser executada em segundo plano Adormecer por um tempo determinado – Sleep(x) Suspender - Suspend Retomar - Resume Interromper – Interrupt Abortar - Abort
- 45. Threads no C#: Os leitores e escritores Programa desenvolvido com a solução para o problema dos leitores e escritores