Please enable JavaScript.
Coggle requires JavaScript to display documents.
Comunicação e Sincronização de Processos - Coggle Diagram
Comunicação e Sincronização de Processos
Soluções para programação concorrente
As 4 regras de uma solução boa para programação concorrente
Dois ou mais processos não podem estar
simultaneamente dentro de uma região crítica
Não se podem fazer afirmações em relação à
velocidade e ao número de CPUs
Um processo fora da região crítica não deve causar
bloqueio a outro processo
Um processo não pode esperar infinitamente para
entrar na região crítica
Espera Ocupada (Busy Waiting)
Thread constantemente verifica se uma determinada condição foi satisfeita, em vez de aguardar passivamente que essa condição seja atendida.
Menos eficiente do que a espera passiva
Consumo de recursos
Primitivas Sleep/Wake Up
permitem a um processo ou thread esperar por um determinado período de tempo antes de continuar a sua execução.
Usados para acesso a variáveis compartilhadas
Como as variáveis são explicitamente declaradas, não existem ``efeitos colaterais''
Simples de usar e entender
Separam sincronização e espera
Evitam espera ocupada
Troca de Mensagens.
Threads em um sistema se comunicam enviando e recebendo mensagens uns dos outros
forma eficaz e segura de comunicação entre processos ou threads
Problemas clássicos
Produtor e Consumidor
se trata da comunicação entre processos que
produzem
itens e os colocam em uma fila, e outros processos que retiram esses itens da fila para
uso
Como coordenar a produção e consumo para que o consumo de itens inexistentes ou produção de itens em uma fila cheia não aconteça?
Jantar dos Filósofos
um grupo de filósofos sentados em uma mesa circular que compartilham pratos de comida e precisam alternar entre comer e pensar, mas para comer, precisam pegar dois garfos que estão ao lado do seu prato
Vários filósofos tentam pegar os garfos ao mesmo tempo, causando bloqueio na execução do programa
Como evitar condições de corrida e bloqueios?
Leitores e Escritores
Um grupo de threads ou processos que compartilham um recurso, e precisam ler ou escrever nesse recurso de forma segura e coordenada.
Threads ou processos tentam acessar o recurso ao mesmo tempo, causando erros de concorrência, como escrita incorreta ou leitura de dados desatualizados.
Como garantir que um leitor não leia dados não atualizados ou que um escritor não escreva em dados não lidos?