Monitors: An Operating System Structuring Concept - C A R Hoare --------------------------------------------------------------- A monitor is a collection of data and procedures which are used for aquiring and releasing a resource. monitors are similar to objects The monitor variables are private to the monitor, and the monitor procedures cannot access any global variables. Only one thread could be executing a particular monitor's procedure at any time. This is the same as synchronized methods in Java. Operations needed: * wait - issued inside a resource-aquiring monitor procedure, causing a calling thread to wait. The waiting thread will release any mutual exclusion variables before it waits, to allow other threads into the monitor * signal - issued inside a resource-releasing monitor procedure to atomically wake exactly one thread waiting for the resource condition variable: to distinguish between different types of waits and signals. notation: condvar.wait; condvar.signal; condition var does not have any ``value'' as such. Simple scheduling problem for a single resource: simulates a semaphore; hence monitor concept is atleast as powerful as semaphores Fairness among multiple waiting threads desired Implementation of monitors using semaphores: - Each monitor procedure has a P(mutex) at its beginning and V(mutex) at the end - Each conditional variable in the monitor has a semaphore condsem associated with it condvar { semaphore condsem; int condcount; wait() { condcount++; if(urgentcount > 0) V(urgent) else V(mutex); P(condsem); condcount--; } signal() { urgentcount++; if(condcount > 0) {V(condsem); P(urgent)} urgentcount--; } } - basically the idea in the above implementation is that one thread passes on the ``baton'' to other threads, so that only one thread is executing any part of the monitor code - This mechanism is not just a recommended style of using semaphores. It is as different from semaphores as for loop is from jumps. - In practice the implementation can be made more efficient Bounded Buffer example Scheduled waits: include a thread priority in the conditional wait so that the thread with lowest priority can be awakened on a signal. cond.wait(p) Also cond.queue() which returns true if any thread is waiting on cond Alarm clock example, Disk head scheduler, readers and writers example