Monitor

1. Monitor

• high-level synchronization construct that allows the safe-sharing of an abstract data type among concurrent processes

monitor monitor-name{

    shared variable declarations

    procedure body p1(){}

    procedure body p2() {}

    procedure body pn() {}

    {

        initialization code

    }

}

2. Schematic View of a Monitor

• the monitor construct ensures that at most one process can be active within the monitor at a given time
• shred data (local variables) of the monitor can be accessed only by local procedure

3. Monitors Introduction

• to allow a process to wait within the monitor
• a condition variable must be declared, as condition x, y
• condition variable can only be used with the operation wait and signal
• the operation 
• x.wait() means that the process invoking this operation is suspended until another process invokes x..signal()
• x.signal() operation resumes exactly one suspend process on condition variable x. If no process is suspended on condition variable x, then the signal operation has no effect.
• wait and signal operations of the monitors are not the same as semaphore wait and signal operations

4. Monitor with condition variables

• when a process P signal to wake up process Q that was waiting on a condition, potentially both of them can be active.
• however, monitor rules require that at most one process can be active within the monitor
• signal and wait: P waits until Q leaves the monitor
• signal and continue: Q waits until P leaves the monitor (or, until P waits for another condition)
• Signal and leave: P has to leave the monitor after signaling
• the design decision is different for different programming languages

5. Procedure-Consumer Problem With Monitor

6. Dining-Phisolophers Problem with Monitors