Monitor pattern là gì? Cách implement producer-consumer problem?

Monitor là high-level synchronization construct: object chứa mutex (đảm bảo mutual exclusion) + condition variables (cho phép threads wait/notify). Producer-Consumer problem: producer thêm item vào bounded buffer, consumer lấy ra; khi buffer đầy producer phải chờ; khi buffer rỗng consumer phải chờ. Implement với Java (built-in monitor):

synchronized void produce(Item item) {
    while (buffer.isFull()) wait(); // release lock, wait
    buffer.add(item);
    notifyAll(); // wake up waiting consumers
}
synchronized Item consume() {
    while (buffer.isEmpty()) wait();
    Item item = buffer.remove();
    notifyAll(); // wake up waiting producers
    return item;
}

Go implementation thường dùng channel:

ch := make(chan Item, bufferSize)
// Producer
ch <- item
// Consumer
item := <-ch

Go channel built-in implement producer-consumer pattern với blocking semantics. Semaphore approach: dùng counting semaphore empty (=N) và full (=0) + mutex — classic Dijkstra solution. Java BlockingQueue: production-ready implementation.

A Monitor is a high-level synchronization construct: an object containing a mutex (ensuring mutual exclusion) plus condition variables (allowing threads to wait and be notified). Producer-Consumer problem: producers add items to a bounded buffer; consumers remove them; when the buffer is full the producer must wait; when empty the consumer must wait. Java implementation (built-in monitor):

synchronized void produce(Item item) {
    while (buffer.isFull()) wait(); // release lock, wait
    buffer.add(item);
    notifyAll(); // wake up waiting consumers
}
synchronized Item consume() {
    while (buffer.isEmpty()) wait();
    Item item = buffer.remove();
    notifyAll(); // wake up waiting producers
    return item;
}

Go implementation typically uses channels:

ch := make(chan Item, bufferSize)
// Producer
ch <- item
// Consumer
item := <-ch

Go channels natively implement the producer-consumer pattern with blocking semantics. Semaphore approach: use counting semaphores empty (=N) and full (=0) plus a mutex — the classic Dijkstra solution. Java BlockingQueue: the production-ready implementation.