Semáforo vs Monitor
Semaphore é uma estrutura de dados que é usada para garantir que vários processos não acessem um recurso comum ou uma seção crítica ao mesmo tempo, em ambientes de programação paralela. Semáforos são usados para evitar dead locks e condições de corrida. Monitor é uma construção de linguagem de programação que também é usada para evitar que vários processos acessem um recurso comum ao mesmo tempo, portanto, garante a exclusão mútua. Os monitores usam variáveis condicionais para realizar essa tarefa.
O que é um semáforo?
Semaphore é uma estrutura de dados que é usada para fornecer exclusão mútua para seções críticas. Os semáforos suportam principalmente duas operações chamadas wait (historicamente conhecido como P) e sinal (historicamente conhecido como V). A operação de espera bloqueia um processo até que o semáforo seja aberto e a operação de sinal permita a entrada de outro processo (thread). Cada semáforo está associado a uma fila de processos em espera. Quando a operação de espera é chamada por um encadeamento, se o semáforo estiver aberto, o encadeamento pode continuar. Se o semáforo é fechado quando a operação de espera é chamada por uma thread, a thread é bloqueada e tem que esperar na fila. A operação de sinal abre um semáforo e se já houver uma thread esperando na fila, esse processo tem permissão para prosseguir e se não houver threads esperando na fila o sinal é lembrado para as próximas threads. Existem dois tipos de semáforos chamados semáforos mutex e semáforos de contagem. Os semáforos mutex permitem um único acesso a um recurso e os semáforos de contagem permitem que várias threads acessem um recurso (que possui várias unidades disponíveis).
O que é um Monitor?
Um monitor é uma construção de linguagem de programação que é usada para controlar o acesso a dados compartilhados. Os monitores encapsulam estruturas de dados compartilhadas, procedimentos (que operam em estruturas de dados compartilhadas) e sincronização entre invocações de procedimentos simultâneos. Um monitor garante que seus dados não sejam confrontados com acessos não estruturados e garante que os treads (que acessam os dados do monitor por meio de seus procedimentos) interagem de forma legítima. Um monitor garante a exclusão mútua permitindo que apenas um thread execute qualquer procedimento de monitor em um determinado momento. Se outro encadeamento tentar invocar um método no monitor, enquanto um encadeamento já estiver executando um procedimento no monitor, o segundo procedimento será bloqueado e terá que aguardar na fila. Existem dois tipos de monitores chamados monitores Hoare e monitores Mesa. Eles diferem principalmente em sua semântica de agendamento.
Qual é a diferença entre Semáforo e Monitor?
Mesmo que tanto os semáforos quanto os monitores sejam usados para alcançar a exclusão mútua em ambientes de programação paralela, eles diferem nas técnicas usadas para realizar essa tarefa. Nos monitores, o código que é usado para obter a exclusão mútua está em um único local e é mais estruturado, enquanto o código para semáforos é distribuído como chamadas de função de espera e sinal. Além disso, é muito fácil cometer erros ao implementar semáforos, enquanto há uma chance muito pequena de cometer erros ao implementar monitores. Além disso, os monitores usam variáveis de condição, enquanto os semáforos não.
