https://github.com/willmendesneto/tlbs-producer-consumer-problem

Code example of The Little Book of Semaphores Cap 4: Producer-Consumer Problem
https://github.com/willmendesneto/tlbs-producer-consumer-problem

Last synced: about 2 months ago
JSON representation

Code example of The Little Book of Semaphores Cap 4: Producer-Consumer Problem

• Host: GitHub
• URL: https://github.com/willmendesneto/tlbs-producer-consumer-problem
• Owner: willmendesneto
• Created: 2013-08-05T12:41:53.000Z (over 11 years ago)
• Default Branch: master
• Last Pushed: 2013-08-07T02:39:04.000Z (over 11 years ago)
• Last Synced: 2023-03-23T03:36:55.545Z (almost 2 years ago)
• Language: JavaScript
• Size: 211 KB
• Stars: 0
• Watchers: 0
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
How to

O código é usado da seguinte maneira:

Existe uma lista de botões que simulam os eventos para serem inseridos ao "Buffer". A lista acima corresponde à fila de processos que estão no "Buffer" em espera que que uma instância da classe "Consumer" as processe.

Ao clicar no botão "Iniciar Consumer" o buffer ficará inacessível para a instância da classe "Producer".

Uma instância da classe "Semaphore" está responsável por verificar o acesso ao buffer de processos. Quando uma das duas instâncias (Producer ou Consumer) for acessar o buffer, fechará para a outra e vice-versa.

Problema do produtor-consumidor

Em programas multithread muitas vezes há uma divisão de trabalho entre os segmentos. em

um padrão comum, alguns tópicos são produtores e alguns são consumidores. produtores

criar itens de algum tipo e adicioná-los a uma estrutura de dados, os consumidores

remover os itens e processá-los.

Programas event-driven são um bom exemplo. Um "evento" é algo que

Acontece que requer o programa para responder: o usuário pressiona uma tecla ou movimentos

do rato, um bloco de dados chega a partir do disco, chega um pacote a partir do

rede, uma operação pendente concluída.

Sempre que ocorre um evento, um segmento produtor cria um objeto de evento e

adiciona-lo para o buffer de eventos. Ao mesmo tempo, segmentos de consumo ter eventos fora

do buffer e processá-los. Neste caso, os consumidores são chamados de "evento

manipuladores ".

Há várias restrições de sincronização que precisamos cumprir para

fazer este sistema funcionar corretamente:

Enquanto um item está sendo adicionado ou removido do buffer, o buffer é

em um estado inconsistente. Portanto, os tópicos devem ter acesso exclusivo a

o tampão.

• Se um segmento consumidor chega, enquanto o buffer está vazio, ele bloqueia até que um

produtor adiciona um novo item.

Suponha que os produtores de realizar as seguintes operações mais e mais:

* Código 1;

    event = waitForEvent()

    buffer.add(event)

Além disso, assume que o consumidor realizar as seguintes operações:

* Código 2;

    event = buffer.get()

    event.process()

Como especificado acima, o acesso ao tampão tem de ser exclusivas, mas

waitForEvent e event.process podem ser executados simultaneamente.

Puzzle: Adicionar declarações de sincronização com o código do produtor e do consumidor

para impor as restrições de sincronização.