Slide 1Programmatuur voor real-time controleYolande Berbers RTPReal-Time Programmatuur hoofdstuk 8: synchronisatie en communicatie met gedeelde variabelen.

Presentatie over: "Slide 1Programmatuur voor real-time controleYolande Berbers RTPReal-Time Programmatuur hoofdstuk 8: synchronisatie en communicatie met gedeelde variabelen."— Transcript van de presentatie:

1 slide 1Programmatuur voor real-time controleYolande Berbers RTPReal-Time Programmatuur hoofdstuk 8: synchronisatie en communicatie met gedeelde variabelen

2 RTP slide 2Programmatuur voor real-time controleYolande Berbers overzicht n probleemstelling: u producer - consumer probleem u kritische sectie en conditionele synchronisatie n oplossing 1: busy waiting, suspend/resume: zie boek n oplossing 2: semaforen u gebruik in POSIX n oplossing 3: conditionele kritische secties n oplossing 4: monitors u gebruik in POSIX n protected objects in Ada n synchronized klassen in Java

3 RTP slide 3Programmatuur voor real-time controleYolande Berbers Producer - Consumer Concurrent: … need buffer...

4 RTP slide 4Programmatuur voor real-time controleYolande Berbers Producer - Consumer n Unbounded Buffer u Consumer: Wait if buffer empty n Bounded Buffer u Consumer: Wait if buffer empty u Producer: Wait if buffer full Synchronization

5 RTP slide 5Programmatuur voor real-time controleYolande Berbers Producer - Consumer out in out Circular buffer

6 RTP slide 6Programmatuur voor real-time controleYolande Berbers Producer - Consumer in out in Circular buffer

7 RTP slide 7Programmatuur voor real-time controleYolande Berbers while(true) { ic = buffer[out]; out = (out + 1) % n; counter--; consume(ic); } Producer - Consumer Producer Item ip; Consumer Item ic; while (counter == n) {} while (counter == 0) {} while (true) { ip = produce(...); buffer[in] = ip; in = (in+1) % n; counter++; }

8 RTP slide 8Programmatuur voor real-time controleYolande Berbers Producer - Consumer counter++counter-- Monoprocessor: Preemption between Load and Store Multiprocessor: Interleaving (Load before Load and Store) Load Rp,counter Incr Rp Store Rp,counter Load Rc,counter Decr Rc Store Rc,counter

9 RTP slide 9Programmatuur voor real-time controleYolande Berbers Producer - Consumer COUNTER = 4 Load Rp,COUNTER Incr Rp Load Rc,COUNTER Decr Rc Store Rc,COUNTER COUNTER = 3 COUNTER = 5 Store Rp,COUNTER Process Control Block (Producer) Rp=5

10 RTP slide 10Programmatuur voor real-time controleYolande Berbers Producer - Consumer COUNTER = 4 Race condition # processes manipulate same data structure outcome depends on execution order COUNTER = 3 COUNTER = 4 COUNTER = 5 (incorrect) (correct) (incorrect)

11 RTP slide 11Programmatuur voor real-time controleYolande Berbers Critical Section Problem n { P 0, P 1,...,P n-1 } with P i process / thread n code accessing shared variable = critical section n At most one P i executing in its critical section n Process: Critical Section (CS)... Remainder Section (RS)... Entry Exit Protocol

12 RTP slide 12Programmatuur voor real-time controleYolande Berbers Critical Section Problem n Mutual Exclusion (Correctness) u at most one process in its critical section n Progress (Lifeness) u only processes not in RS may participate u decision not postponed indefinitely n Bounded Waiting (Fairness) u bound on # times surpassed

13 RTP slide 13Programmatuur voor real-time controleYolande Berbers Cooperating Processes Cooperating Concurrent Processes (Threads): n outcome may be not deterministic n execution may be not reproducible (bugs …) n stop / resume processes may affect outcome!

14 RTP slide 14Programmatuur voor real-time controleYolande Berbers semaforen n wat: eenvoudig laag-niveau mechanisme voor wederzijdse uitsluiting en conditionele synchronisatie n hoe u niet-negatieve geheel getal u kan geïnitialiseerd worden l 1 bij binaire semaforen l gelijk welk positief getal bij tellende semaforen u twee ondeelbare (atomaire) operaties zijn mogelijk l wait(S)oorspronkelijk P(S) indien S > 0: verlaag S met 1, anders wacht tot S > 0 en verlaag dan l signal (S)oorspronkelijk V(S) verhoog S met 1 n mogelijke problemen: deadlock, verhongering

15 RTP slide 15Programmatuur voor real-time controleYolande Berbers semaforen Dijkstra

16 RTP slide 16Programmatuur voor real-time controleYolande Berbers semaforen n Integer value  0 0 means CLOSED Higher value: More open (Atomic) Operations: Initialization P (proberen)waitlock V (verhogen)signalunlock >0 means OPEN

17 RTP slide 17Programmatuur voor real-time controleYolande Berbers semaforen P(s)  while (s == 0) { } WAIT C-Note: P and V are not procedure calls! V(s)  s++; s-- ;

18 RTP slide 18Programmatuur voor real-time controleYolande Berbers semaforen : gebruik kritische sectie n Critical Section typedef semaphore int; semaphore s = 1; while (true) { Critical Section … Remainder section … } P(& s); V(& s); C-Note: P and V are defined as procedure calls!

19 RTP slide 19Programmatuur voor real-time controleYolande Berbers … Action2;... semaforen : gebruik synchronisatie n Synchronization Process 1Process 2 …... Action1Action2 …... semaphore s = 0 … Action1;... P(&s); V(&s); P (&s); V (&s);

20 RTP slide 20Programmatuur voor real-time controleYolande Berbers semaforen : problemen n deadlock semaphore s = 1; semaphore r = 1; n vehongering u possible if the queue is not a FIFO queue P1P2 P(s); // s == 0… …P(r); // r == 0 P(r);…

21 RTP slide 21Programmatuur voor real-time controleYolande Berbers binaire semaforen n Two states: u locked u open lock (s)  while (s == locked) { } s = locked; unlock (s)  s = open; Note: unlock(s) when open = NOP locked open

22 RTP slide 22Programmatuur voor real-time controleYolande Berbers while (true) { ip = produce (…); insert (buffer, ip); } Producer while (true) { ic = remove (buffer); consume (ic); } Consumer semaforen: producer-consumer … buffer … P (&mutex); V (&mutex); P (&mutex); V (&mutex); semaphore mutex = 1; V (&full); semaphore empty = 0; semaphore full = N; V (&empty); P (&full); P (&empty); CS

23 RTP slide 23Programmatuur voor real-time controleYolande Berbers semaforen: producer-consumer P (&mutex); P (&full); while (true) { ip = produce (…); insert (buffer, ip); } Producer while (true) { ic = remove (buffer); consume (ic); } Consumer P (&mutex); V (&mutex); semaphore mutex = 1; V (&full); semaphore empty = 0; semaphore full = N; V (&empty); P (&full); … buffer … P (&mutex); P (&empty); Deadlock if full == 0

24 RTP slide 24Programmatuur voor real-time controleYolande Berbers ondersteuning voor semaforen n Ada, Java u geen directe ondersteuning in de taal u gemakkelijk om een package/klasse te maken die het aanbiedt voor gebruik tussen taken u 8.4.5: klassiek voorbeeld van producer/consumer in Ada n C u geen ondersteuning n POSIX u tellende semaforen tussen aparte processen en voor verschillende threads in een proces

25 RTP slide 25Programmatuur voor real-time controleYolande Berbers n standard operations for counting semaphores u initialize, wait, signal typedef … sem_t; int sem_init (sem_t *sem_location, int pshared, unsigned int value); /* initializes the semaphore at location sem_location to value pshared determines if used between processes or threads or only between threads of the same process */ int sem_wait (sem_t *sem_location); /* a standard wait operation on a semaphore */ int sem_post (sem_t *sem_location); /* a standard signal operation on a semaphore */ POSIX semaforen

26 RTP slide 26Programmatuur voor real-time controleYolande Berbers int sem_trywait (sem_t *sem_location); /* attempts to decrement the semaphore returns -1 if the call might block the calling process */ int sem_getvalue (sem_t *sem_location, int *value); /* gets the current value of the semaphore to a location pointed at by value */ POSIX semaforen n non-standard operations for counting sem. u non-blocking wait, determining value of sem.

27 RTP slide 27Programmatuur voor real-time controleYolande Berbers nadelen van semaforen n semaforen leiden gemakkelijk tot fouten (en zijn dus ongeschikt in real-time programmatuur) u vergeet er 1 en het programma loopt fout u heel moeilijk om te vinden waar precies wait of signal vergeten u deadlock kan gemakkelijk optreden (misschien maar in heel weinig voorkomende gevallen, maar dat is juist moeilijk te testen)

28 RTP slide 28Programmatuur voor real-time controleYolande Berbers conditionele kritische sectie n wat: een code-segment met garantie voor uitvoering onder wederzijdse uitsluiting, en met mogelijkheid tot conditionele synchronisatie n hoe: u groepering van variabelen die beschermd moeten worden in code-segmenten (region) die een naam krijgen u wachtercode (guard) mogelijk voor conditionele synchronisatie n nadelen u een proces dat wacht om binnen te treden moet, telkens er een ander proces uittreedt, actief gemaakt worden voor het testen van de wachtercode u de code-segmenten kunnen ongestructureerd verspreid zijn over het programma

29 RTP slide 29Programmatuur voor real-time controleYolande Berbers conditionele kritische sectie: voorbeeld process producer;... loop region buf when buffer.size < N do -- plaats een character in de buffer end region... end loop end process consumer... loop region buf when buffer.size > 0 do -- neem een character uit de buffer end region... end loop end

30 RTP slide 30Programmatuur voor real-time controleYolande Berbers monitors n wat u gestructureerde manier om code-segmenten te schrijven met garantie voor uitvoering onder wederzijdse uitsluiting, en met mogelijkheid tot conditionele synchronisatie n hoe u module met een verzameling van kritische secties die elk als procedure of functie geschreven zijn u module heet monitor u alle variabelen die beschermd moeten worden zijn verborgen (information hiding) u conditie variabelen voor conditionele synchronisatie l wait: blokkeert altijd het uitvoerende proces l signal: deblokkeert een wachtend proces indien er zo één is

31 RTP slide 31Programmatuur voor real-time controleYolande Berbers monitor: voorbeeld monitor buffer; export append, take; const size = 32; var buf: array[0...suze-1] of integer; top, base : 0.. size-1; SpaceAvailable, ItemAvailable : condition; NumberInBuffer : integer; procedure append (I : integer)..... procedure take (var I : integer)..... begin (* initialisatie *) NumberInBuffer := 0; top := 0; base := 0 end;

32 RTP slide 32Programmatuur voor real-time controleYolande Berbers monitor: voorbeeld procedure append (I : integer); begin if (NumberInBuffer = size) then wait (SpaceAvailable); buf[top] := I; NumberInBuffer := NumberInBuffer + 1; top := (top + 1) mod size; signal (ItemAvailable); end append; procedure take (var I : integer); begin if (NumberInBuffer = 0) then wait (ItemAvailable); I := buf[base]; base := (base + 1) mod size; NumberInBuffer := NumberInBuffer - 1; signal (SpaceAvailable); end take;

33 RTP slide 33Programmatuur voor real-time controleYolande Berbers monitors (commentaar bij voorbeeld) n minstens 2 processen zijn betrokken u één producent (maar het kunnen er meerdere zijn) u één consument (maar het kunnen er meerdere zijn) n processen kunnen geblokkeerd zijn u omdat ze de monitor proberen binnen te gaan l ze proberen append of take uit te voeren u omdat ze wachten op een conditie l er is bv geen plaats in de buffer l of er zijn geen elementen in de buffer n er is dus een mogelijke wachtrij u voor de monitor zelf u en voor elke conditievariabele

34 RTP slide 34Programmatuur voor real-time controleYolande Berbers monitors thread executing in monitor thread requesting monitor access monitor condition var a procedure function condition var b

35 RTP slide 35Programmatuur voor real-time controleYolande Berbers monitors n welk proces mag (exclusief) uitvoeren na een signal ? u proces dat signal uitvoert (proces dat een wait deed wacht nog even) u proces dat een wait deed (proces dat de signal doet moet nu wachten) n mogelijke semantiek voor signal u signal mag alleen als laatse instructie voor verlaten van monitor l zoals in het producer/consumer voorbeeld l niet erg flexibel u signal heeft als neven-effect een return (dus het uitvoerend proces wordt verplicht de monitor te verlaten) u proces dat signal uitvoert blijft uitvoeren; proces dat gedeblokkeerd is moet daarna weer vechten om de monitor te mogen betreden u proces dat de signal uitvoert blokkeert, en proces dat gedeblokkeerd werd mag direct uitvoeren

36 RTP slide 36Programmatuur voor real-time controleYolande Berbers monitors n voordeel van monitors u gestructureerde manier voor het programmeren van wederzijdse uitsluiting n nadeel van monitors u laag-niveau manier voor het programmeren van conditionele synchronisatie

37 RTP slide 37Programmatuur voor real-time controleYolande Berbers mutexes and condition variables in POSIX n wederzijdse uitluiting: u aan elke monitor koppelt men een mutex variabele u operaties van monitor moeten omringd worden door oproepen lock en unlock van mutex n conditie synchronizatie: u door conditievariabelen gekoppeld aan mutex u thread wacht op conditievariabele: lock op geassocieerde mutex komt vrij u thread hervat na wachten op conditievariabele: thread heeft lock weer

38 RTP slide 38Programmatuur voor real-time controleYolande Berbers int pthread_mutex_init (pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); /* initializes a mutex with certain attributes */ int pthread_mutex_lock (pthread_mutex_t *mutex); /* lock the mutex; if already locked suspend calling thread the owner of the mutex is the thread which locked it */ int pthread_mutex_unlock (pthread_mutex_t *mutex); /* unlock the mutex if called by the owning thread undefined behavior if the calling thread is not the owner undefined behavior if the mutex is not locked when successful, results in release of a blocked thread */ mutexes and condition variables in POSIX

39 RTP slide 39Programmatuur voor real-time controleYolande Berbers int pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *attr); /* initializes a condition variable with certain attributes */ int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex); /* called by thread which owns a locked mutex (undefined behavior if the mutex is not locked) atomically blocks the calling thread on the cond variable and releases the lock on mutex a successful return indicates that the mutex has been locked */ int pthread_cond_signal (pthread_cond_t *cond); /* unblocks at least 1 blocked thread; no effect if no threads are blocked; unblocked threads automatically contend for the associated mutex /* mutexes and condition variables in POSIX

40 RTP slide 40Programmatuur voor real-time controleYolande Berbers int pthread_mutex_trylock (pthread_mutex_t *mutex); /* the same as lock but gives error return if mutex already locked */ int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex, const st’ruct timespec *abstime); /* the same as pthread_cond_wait, except that an error is returned if the timeout expires */ mutexes and condition variables in POSIX

41 RTP slide 41Programmatuur voor real-time controleYolande Berbers n example: bounded buffer consisting of u mutex u two condition variables (buffer_not_full and buffer_not_empty) u a count of number of elements u the buffer itself u the positions of first and last items in buffer u routine ‘append’ u routine ‘take’ mutexes and condition variables in POSIX: producer-consumer

42 RTP slide 42Programmatuur voor real-time controleYolande Berbers #define SYS_CALL (A) if (sys_call(A) != 0) error() /* where error is function which undertakes some error processing */ n note: lighter notation for calls in POSIX u error conditions from POSIX: return -1 u for reliability: every call to system function should test the return value u in book: macro mutexes and condition variables in POSIX: producer-consumer

43 RTP slide 43Programmatuur voor real-time controleYolande Berbers # include “pthreads.h” # define BUFF_SIZE 10 typedef struct { pthread_mutex_t mutex; pthread_cond_t buffer_not_full; pthread_cond_t buffer_not_empty; int count, first, last; int buf [BUFF_SIZE]; } buffer; /* an initialize routine is required */ mutexes and condition variables in POSIX: producer-consumer

44 RTP slide 44Programmatuur voor real-time controleYolande Berbers int append (int item, buffer *B) { PTHREAD_MUTEX_LOCK (&B->mutex); while (B->count == BUFF_SIZE) PTHREAD_COND_WAIT (&B->buffer_not_full, &B->mutex); /* put data in buffer and update count and last */ PTHREAD_MUTEX_UNLOCK (&B->mutex); PTHREAD_COND_SIGNAL (&B->buffer_not_empty); return 0; } mutexes and condition variables in POSIX: producer-consumer

45 RTP slide 45Programmatuur voor real-time controleYolande Berbers int take (int *item, buffer *B) { PTHREAD_MUTEX_LOCK (&B->mutex); while (B->count == 0) PTHREAD_COND_WAIT (&B->buffer_not_empty, &B->mutex); /* get data from buffer and update count and first */ PTHREAD_MUTEX_UNLOCK (&B->mutex); PTHREAD_COND_SIGNAL (&B->buffer_not_full); return 0; } mutexes and condition variables in POSIX: producer-consumer

46 RTP slide 46Programmatuur voor real-time controleYolande Berbers protected objects (enkel in Ada) n wat: gestructureerde manier voor het programmeren van u code-segmenten met garantie voor uitvoering onder wederzijdse uitsluiting u conditionele synchronisatie n hoe u analoog aan monitors (genoemd protected type) voor wederzijdse uitsluiting l maar meerdere lezers enkelvoudige schrijvers mogelijk u analoog aan conditionele kritische secties (gebruik van barriers (guard) bij entries) voor conditionele synchronisatie l entry is analoog aan procedure, maar kan slechts uitgevoerd worden indien aan de barrier voldaan is l oproepen van entry zoals van een procedure

47 RTP slide 47Programmatuur voor real-time controleYolande Berbers protected objects n een protected body heeft u een specificatie u een body n kunnen voorzien worden in de specificatie u entries: dit zijn procedures die voorzien zijn van een conditie l voorwaarde voor uitvoeren: niemand voert het protected object uit en de conditie is waar u procedures: zijn niet voorzien van een conditie l voorwaarde voor uitvoeren: niemand voert protected object uit u functies: zijn niet voorzien van een conditie l voorwaarde voor uitvoeren: niemand of alleen andere functies voeren protected object uit (dit implementeert meerdere lezers)

48 RTP slide 48Programmatuur voor real-time controleYolande Berbers Write Access to Protected Object task executing with read access task requesting read access task executing with read/write access task requesting read/write access protected object barrier queue procedure entry function

49 RTP slide 49Programmatuur voor real-time controleYolande Berbers Read Access to Protected Object task executing with read access task requesting read access task executing with read/write access task requesting read/write access protected object procedure entry function barrier queue

50 RTP slide 50Programmatuur voor real-time controleYolande Berbers protected object: voorbeeld 1 protected type Shared_Integer (Initial_Value: Integer) is function read return Integer; procedure Write (New_Value: Integer); procedure Increment (By: Integer); private The_Data : Integer := Initial_Value; end Shared_Integer; My_Data: Shared_Integer(42);

51 RTP slide 51Programmatuur voor real-time controleYolande Berbers protected object: voorbeeld 1 protected body Shared_Integer is function Read return Integer is begin return The_Data; end Read; procedure Write (New_Value: Integer) is begin The_Data := New_Value; end Write; procedure Increment (By: Integer) is begin The_Data := The_Data + By; end Increment; end Shared_Integer;

52 RTP slide 52Programmatuur voor real-time controleYolande Berbers protected object: voorbeeld 2 Buffer_Size : constant Integer := 10; type Index is mod Buffer_Size; subtype Count is Natural range 0.. Buffer_Size; type Buffer is array (Index) of Data_Item; protected type Bounded_Buffer is entry Get (Item: out Data_Item); entry Put (Item: in Data_Item); private First : Index := Index’First; Last : Index := Index’Last; Number_In_Buffer : Count := 0; Buf : Buffer; end Bounded_Buffer; My_Buffer: Bounded_Buffer;

53 RTP slide 53Programmatuur voor real-time controleYolande Berbers protected object: voorbeeld 2 protected body Bounded_Buffer is entry Get (Item: out Data_Item) when Number_In_Buffer > 0 is begin Item := Buf(First); First := First + 1; Number_In_Buffer := Number_In_Buffer - 1; end Get; entry Put (Item: in Data_Item) when Number_In_Buffer < Buffer_Size is begin Last := Last + 1; Buf(Last) := Item; Number_In_Buffer := Number_In_Buffer + 1; end Put; end Bounded_Buffer;

54 RTP slide 54Programmatuur voor real-time controleYolande Berbers protected object: voorbeeld 3 protected Resource_Control is entry Allocate; procedure Deallocate; private Free : Boolean := True; end Resource_Control; protected body Resource_Control is entry Allocate when Free is begin Free := False; end Allocate; procedure Deallocate is begin Free := True; end Deallocate; end Resource_Control ;

55 RTP slide 55Programmatuur voor real-time controleYolande Berbers protected object: voorbeeld 4 n een taak wil een boodschap sturen naar andere taken die hierop wachten n indien er geen wachtende taken zijn wordt er geen boodschap achtergelaten protected type Broadcast is entry Receive (M: out Message); procedure Send (M: Message); private New_Message : Message; Message_Arrived : Boolean := False; end Broadcast ;

56 RTP slide 56Programmatuur voor real-time controleYolande Berbers protected object: voorbeeld 4 protected body Broadcast is entry Receive (M: out Message) when Message_Arrived is begin M := New_Message; if Receive’Count = 0 then Message_Arrived := False; end if; end Receive; procedure Send (M: Message) is begin if Receive’Count > 0 then Message_Arrived := True; New_Message := M; end if; end Send; end Broadcast ;

57 RTP slide 57Programmatuur voor real-time controleYolande Berbers protected object: voorbeeld 5 n pakket dat semaforen aanbiedt, geïmplementeerd met behulp van een protected object package Semaphore_Package is type Semaphore (Initial : Natural := 1) is limited private; procedure Wait (S: in out Semaphore); procedure Signal (S: in out Semaphore); private protected type Semaphore (Initial : Natural := 1) is entry Wait_Imp; procedure Signal_Imp; private Value: Natural := Initial; end Semaphore ; end Semaphore_Package ;

58 RTP slide 58Programmatuur voor real-time controleYolande Berbers protected object: voorbeeld 5 package body Semaphore_Package is protected body Semaphore is entry Wait_Imp when Value > 0 is beginValue := Value - 1; end Wait_Imp; procedure Signal_Imp is beginValue := Value + 1; end Signal_Imp; end Semaphore; end Semaphore_Package ; procedure Wait (S: in out Semaphore); begin S.Wait_Imp end Wait; procedure Signal (S: in out Semaphore); begin S.Signal_Imp end Signal; end Semaphore_Package ;

59 RTP slide 59Programmatuur voor real-time controleYolande Berbers Synchronization in Java Object Waiting Queue Ma Ms Ma Ms Synchronised methods Ms Unsynchronised methods Mb Ma Comparable to monitor with 1 condition variable Waiting to acquire the lock Called wait();

60 RTP slide 60Programmatuur voor real-time controleYolande Berbers Synchronization in Java Object Waiting Queue Ms Ma Mb wait() Mt

61 RTP slide 61Programmatuur voor real-time controleYolande Berbers Synchronization in Java Object Waiting Queue Ms Ma Mb Mt notify()

62 RTP slide 62Programmatuur voor real-time controleYolande Berbers Synchronization in Java class BoundedBuffer {... public synchronized void put (int item) {...} public synchronized int get () { … } public int countBuffer () { … } // returns # of items in buffer... } Synchronized: unique lock (mutex) with each instance of that class synchronized method in Critical Section start of method: lock end of method: unlock locking/unlocking atomically

63 RTP slide 63Programmatuur voor real-time controleYolande Berbers Synchronization in Java class ReentrantClass {... public synchronized void a () { …; b(); … } public synchronized void b () { … }... } Java locks : re-entrant thread can reacquire a lock it already holds

64 RTP slide 64Programmatuur voor real-time controleYolande Berbers Synchronization in Java Only part of method is synchronized class PartlySynchronizedClass {... public void c () { …; synchronized (this) { … CS … }... }... }

65 RTP slide 65Programmatuur voor real-time controleYolande Berbers Synchronization in Java Synchronize on another object class PartlySynchronizedClass {... public void d () { …; synchronized (obj) { … CS … }... }... }

66 RTP slide 66Programmatuur voor real-time controleYolande Berbers Synchronization in Java Object.wait() relinquishes the lock waits for a notification resumes when a) notified and b) lock is reacquired Object.wait (long timeout) Object.wait (long timeout, int nanoseconds) Object.notify() notifies one thread waiting on that object Object.notifyAll() notifies all threads waiting on that object Only if Thread owns lock!

67 RTP slide 67Programmatuur voor real-time controleYolande Berbers Condition Variables n Java: no explicit condition variables u awoken thread usually evaluates condition on which it is waiting public class BoundedBuffer { private int buffer[]; private int first; private int last; private int numberInBuffer = 0; private int size; public BoundedBuffer(int length) { size = length; buffer = new int[size]; last = 0; first = 0; };

68 public synchronized void put(int item) throws InterruptedException { if (numberInBuffer == size) { wait(); }; last = (last + 1) % size ; // % is modulus numberInBuffer++; buffer[last] = item; notify(); }; public synchronized int get() throws InterruptedException { if (numberInBuffer == 0) { wait(); }; first = (first + 1) % size ; // % is modulus numberInBuffer--; notify(); return buffer[first]; }; } bij consumer-producer geen while nodig