Monitors & Condition Synchronization

Transcription

1 INF2140 Modeling and programming parallel systems Lecture 5 Feb. 13, 2013

2 Plan for Today: Concepts Monitors: encapsulated data + access procedures Mutual exclusion + condition synchronization Single access procedure active in the monitor Models Guarded actions Practice Private data and synchronized methods (exclusion). wait(), notify() and notifyall() for condition synchronization Single thread active in the monitor at a time

3 Repetition The simplest way for Java threads to interact, is via a shared object: an object whose methods can be invoked by a set of threads Destructive update, caused by the arbitrary interleaving of read and write actions, is called interference. Interference bugs are extremely difficult to locate. The general solution is to give methods mutually exclusive access to shared objects. This can be ensured through Java s synchronized methods

4 Example 1: A Bank Account A simple bank account is shared between a number of people (i.e., client threads). The current balance of the Account should always be the sum of deposits minus the sum of withdrawals. class Account { protected long balance ; public Account ( long initialamount ){ balance = initialamount ; } public void deposit ( int amount ){ balance += amount ; } public void withdraw ( int amount ){ balance -= amount ; } } Question: Is this implementation correct?

5 Monitors in Java Monitor: A language feature which guarantees exclusive access to shared data Concurrent activations of methods on a Java object can be made mutually exclusive by prefixing the method with the keyword synchronized, which uses the lock of the object. Entry queue Monitor Thread3 Thread2 Thread1 lock unlock So far, the only condition for threads to be allowed to execute in the object, is that the lock of the object is free

6 Condition Synchronization Monitors allow more advanced synchronization: when the lock is free, other conditions can control when a thread can enter Entry queue Monitor Thread1 lock unlock Condition queue Thread3 Thread2

7 Example 1: A Bank Account (cont) Synchronized methods solved our previous requirement to the balance of the Account: class Account { protected long balance ; public Account ( long initialamount ){ balance = initialamount ; } public synchronized void deposit ( int amount ){ balance += amount ; } public synchronized void withdraw ( int amount ){ balance -= amount ; } } Question: Can we avoid that the balance becomes negative?

8 Example 1: A Bank Account (cont) Idea: We use condition synchronization to control when a withdraw can execute class Account { protected long balance ; public Account ( long initialamount ){ balance = initialamount ; } public synchronized void deposit ( int amount ){ balance += amount ; notifyall (); } public synchronized void withdraw ( int amount ) throws InterruptedException { while ( amount > balance ) // Condition synchronization wait (); balance -= amount ; } }

9 Example 2: A Car Park A controller is required for a carpark, which only permits cars to enter when the carpark is not full and does not permit cars to leave when there are no cars in the carpark. Car arrival and departure are simulated by separate threads.

10 How to Model the Carpark? Events or actions of interest? arrive and depart Identify processes arrivals, departures and carpark control Define each process and interactions (structure). CARPARK ARRIVALS arrive CARPARK CONTROL depart DEPARTURES

11 Carpark Model ARRIVALS = (arrive->arrivals). DEPARTURES = (depart->departures). CARPARKCONTROL(N=4) = SPACES[N], SPACES[i:0..N] = (when(i>0) arrive->spaces[i-1] when(i<n) depart->spaces[i+1]). Here, i represents the number of available spaces for cars. Guarded actions are used to control arrive and depart. CARPARK = (ARRIVALS CARPARKCONTROL(4) DEPARTURES). LTS?

12 Carpark: From Model to Program Model: all entities are processes interacting by actions Program: need to identify threads and monitors Thread: active entity which initiates (output) actions Monitor: passive entity which responds to (input) actions. For the carpark? CARPARK ARRIVALS arrive CARPARK CONTROL depart DEPARTURES

13 Carpark Program: Class Diagram We omit DisplayThread and GraphicCanvas threads managed by ThreadPanel. Applet Runnable CarPark arrivals, departures ThreadPanel Arrivals carpark cardisplay Departures CarParkControl arrive() depart() CarParkCanvas disp DisplayCarPark

14 Carpark Program Arrivals and Departures implement Runnable. CarParkControl provides the control (condition synchronization). Instances of these are created by the start() method of the CarPark applet: final static int Places = 4; ThreadPanel arrivals ; ThreadPanel departures ; CarParkCanvas cardisplay ; public void start () { CarParkControl c = new DisplayCarPark ( cardisplay, Places ); arrivals. start ( new Arrivals (c )); departures. start ( new Departures (c )); }

15 Carpark Program: Arrivals and Departures Threads class Arrivals implements Runnable { CarParkControl carpark ; Arrivals ( CarParkControl c) { carpark = c;} public void run () { try { while ( true ) { ThreadPanel. rotate (330); carpark. arrive (); ThreadPanel. rotate (30); } } catch ( InterruptedException e ){} } } Similarly: Departures which calls carpark.depart(). How do we implement the control of CarParkControl?

16 Carpark Program: CarParkControl Monitor class CarParkControl { protected int spaces ; protected int capacity ; } CarParkControl ( int n) { capacity = spaces = n;} synchronized void arrive () { spaces ;... } synchronized void depart () { spaces ;... } Mutual exclusion by synchronized methods Condition synchronization? Block if full? spaces==0 Block if empty? spaces==n

17 Condition Synchronization in Java Java provides a thread wait set per monitor (actually per object) with the following methods: public final void notify() Wakes up a single thread waiting on this object s wait set. public final void notifyall() Wakes up all threads that are waiting on this object s wait set. public final void wait() throws InterruptedException Waits to be notified by another thread. The waiting thread releases the synchronization lock associated with the monitor. When notified, the thread must wait to reacquire the monitor before resuming execution.

18 Condition Synchronization in Java We say that a thread enters a monitor when it acquires the mutual exclusion lock associated with the monitor and that it exits the monitor when it releases the lock. wait() causes the thread to exit the monitor, allowing other threads to enter the monitor notify() moves a waiting thread to the entry queue, so it can enter when the monitor is free ( signal and continue monitor)

19 Monitor Locking by wait and notify Thread F C Thread E F Thread B E Monitor Thread B data wait() Thread A notify() Thread A Thread A wait

20 Condition Synchronization in Java FSP: when cond act -> NEWSTAT Java: public synchronized void act () throws InterruptedException { while (! cond ) wait (); // modify monitor data notifyall () } The while loop is necessary to retest cond to ensure that cond is indeed satisfied when the thread re-enters the monitor. notifyall() is necessary to wake other threads waiting to enter the monitor now that the monitor has been changed.

21 CarParkControl: Condition Synchronization class CarParkControl { protected int spaces ; protected int capacity ; CarParkControl ( int n){ capacity = spaces =n;} synchronized void arrive () throws InterruptedException { while ( spaces ==0) wait (); // Condition 1 -- spaces ; notifyall (); } } synchronized void depart () throws InterruptedException { while ( spaces == capacity ) wait (); // Condition 2 ++ spaces ; notifyall (); } Is it safe to use notify() here, instead of notifyall()?

22 notify() or notifyall()? Entry queue Monitor notify() notifyall() Thread1 lock Wait set Condition 1 Condition 2 wait() unlock Thread3 Thread2

23 Monitor Invariants An monitor invariant is an assertion concerning the variables of the monitor. This assertion must hold when no thread is executing in the monitor (i.e., when threads enter and exit the monitor). CarParkControl Invariant: 0 <= space <= capacity Invariants can be helpful in understanding a monitor, and also to reason logically about the correctness of monitors. Can we get help from the monitor invariant to decide if we should use notify() or notifyall()? What are the synchronization conditions of the threads in CarParkControl? Are they always true?

24 Should we use notify() or notifyall()? notify(): One waiting thread moves to the entry queue Problem: What happens if its condition is false? notifyall(): All waiting threads move to the entry queue Problem: All the threads need to recheck their condition Common mistakes when implementing monitors: *** Always check this! *** Not enough notification? Too much notification? Forgot to recheck the condition when a thread is notified? General guidelines notify(): Only when not necessary to recheck condition(s)! notifyall(): Always recheck condition(s)!

25 From Models to Monitors: Summary Active entities (initiating actions) are implemented as threads. Passive entities (responding to actions) are implemented as monitors. Each guarded action in the model of a monitor is implemented as a synchronized method which uses a while loop and wait() to implement the guard. The while loop condition is the negation of the model guard condition. Changes in the state of the monitor are signaled to waiting threads using notify() or notifyall().

26 Summary Concepts Monitors: encapsulated data + access procedures Mutual exclusion + condition synchronization Single access procedure active in the monitor Models Guarded actions Practice Private data and synchronized methods wait(), notify() and notifyall() for condition synchronization Single thread active in the monitor at a time