Monitor

Definição

Monitor é uma abstração de sincronização que combina um conjunto de dados compartilhados com os métodos que os manipulam, garantindo que apenas uma thread possa executar um desses métodos por vez.

O monitor oferece exclusão mútua integrada: não é necessário usar locks explicitamente dentro dos métodos — a própria estrutura garante que o acesso ao estado interno é controlado automaticamente.

Monitores estão presentes de forma nativa em linguagens como Java (com synchronized), e podem ser implementados manualmente em linguagens como Python.

Objetivos do Monitor

Encapsular a sincronização junto com os dados protegidos.
Evitar erros comuns ao usar locks manualmente, como esquecê-los abertos.
Garantir segurança de acesso a métodos críticos, com exclusão mútua automática.
Facilitar a escrita de código concorrente orientado a objetos.

Exemplo prático (implementando um monitor simples em Python)

import threading

class ContaSegura:
    def __init__(self):
        self._saldo = 0
        self._lock = threading.Lock()

    def depositar(self, valor):
        with self._lock:
            self._saldo += valor

    def sacar(self, valor):
        with self._lock:
            if self._saldo >= valor:
                self._saldo -= valor
                return True
            return False

    def consultar(self):
        with self._lock:
            return self._saldo

Agora, vamos usar a classe em duas threads que depositam valores simultaneamente:

conta = ContaSegura()

def fazer_depositos():
    for _ in range(100000):
        conta.depositar(1)

t1 = threading.Thread(target=fazer_depositos)
t2 = threading.Thread(target=fazer_depositos)

t1.start()
t2.start()

t1.join()
t2.join()

print("Saldo final:", conta.consultar())

ℹ️ Monitores encapsulam a sincronização, permitindo que o código que usa a classe (como conta.depositar(...)) não precise se preocupar com locks ou controle concorrente.

Saída esperada

Saldo final: 200000

A classe encapsula o controle de acesso ao saldo com lock, sem exigir que o usuário do código se preocupe com sincronização.
O código é mais seguro, reutilizável e legível, graças à abstração do monitor

Esse exemplo implementa um monitor de forma manual:

O estado interno (_saldo) é protegido.
Todos os métodos de acesso são sincronizados com lock.
O usuário da classe não precisa se preocupar com concorrência — ela está encapsulada.

O ciclo de um Monitor

[Thread A chama método] --> entra no monitor --> executa com exclusão mútua --> sai
[Thread B chama método] --> aguarda liberação do monitor --> executa

Apenas uma thread entra por vez nos métodos protegidos.
O controle de acesso é automático e embutido na estrutura do monitor.

Monitores em linguagens

Java: qualquer objeto pode ser usado como monitor com synchronized.
Python: monitores podem ser implementados com Lock, Condition, ou via bibliotecas.
C#: usa lock(obj) para controlar o acesso, semelhante a Java.
Go / Rust: preferem abstrações explícitas (como canais ou mutexes), mas o padrão se aplica.

Vantagens

Reduz riscos de bugs relacionados à sincronização.
Favorece o encapsulamento.
Facilita testes, manutenção e reaproveitamento de código concorrente.