Monitors

Monitors - definition 1 In concurrent programming, a monitor is a synchronization construct that allows threads to have both mutual exclusion and the ability to wait (block) for a certain condition to become true. Monitors also have a mechanism for signaling other threads that their condition has been met. A monitor consists of a mutex (lock) object and condition variables

Monitors - definition 2 Another definition of monitor is a thread-safe class, object, or module that uses wrapped mutual exclusion in order to safely allow access to a method or variable by more than one thread. The defining characteristic of a monitor is that its methods are executed with mutual exclusion: At each point in time, at most one thread may be executing any of its methods.

Home made monitor class class Account { private semaphore accountSemaphore; // not static…one for every object public void withdraw(int amount) { P(accountSemaphore); balance = balance – amount; V(accountSemaphore); } public void deposit(int amount) balance = balance + amount;

Monitor class monitor class Account { public void withdraw(int amount) { balance = balance – amount; } public void deposit(int amount) balance = balance + amount;

Producer- Consumer Monitor monitor class dijkstraPC { public void producer(int amount) { while(1) while (queue.isFull()) { //busy waiting }; queue.enqueue(produced Stuff); }

Producer- Consumer Monitor public void consumer(int amount) { while(1) while (queue.isEmpty()) { // busy waiting }; queue.dequeue(comsume stuff); }

Spin-waiting In the producer-consumer monitor example, while the producer is waiting for the isFull() condition to be met, it is locking out the consumers from empting out the buffers. while (queue.isFull()) { V(monitor.semaphore); // a chance some other thread may empty a buffer P(monitor.semaphore); };

Condition Variables public void producer(int amount) { while(1) while (queue.isFull()) CP(monitor.semaphore, bufferFull.semaphore); }; queue.enqueue(produced Stuff); }

Synchronization in Java class X { private int a; private int b; public synchronized void addA(){ a++; } public synchronized void addB(){ b++; } // one thread is adding to a, it blocks thread adding to b

Synchronized method per object public void addA() { synchronized( a ) { a++; } public void addB() { synchronized( b ) { b++; } // not allowed in Java because a and b are primitives.

Java Atomic Primitives import java.util.concurrent.atomic.AtomicInteger; class X { AtomicInteger a; AtomicInteger b; public void addA(){ a.increment(); } public void addB(){ b.increment();