JAVA-BASED REAL-TIME PROGRAMMING

class Producer extends Thread {
public void run() {
prod = source.get();
buffer.post(prod);
}
}
class Consumer extends Thread {
public void run() {
cons = buffer.fetch();
sink.put(cons);
}
}
3.3. Objects providing mutual exclusion – Monitors
class Buffer {
synchronized void post(Object obj) {
if (buff.size()== maxSize) wait();
if (buff.isEmpty()) notify();
buff.add(obj);
}
synchronized Object fetch() {
if (buff.isEmpty()) wait();
if (buff.size()== maxSize) notify();
return buff.remove();
}
}
// This Buffer is badly implemented!
Figure 3.8: Classes, with attributes and initialization left out for brevity,
implementing producer-consumer communication via a bounded buffer based
on java.util.ArrayList. The if (...) wait(); makes the buffer fragile: additional
calls of notify (e.g., in other methods) or additional threads could course the
buffering to fail.
is not full. Assuming the simplest case with only one producer and one consumer,
an straightforward but fragile implementation could be according to
Figure 3-8. In a more general setting, with more threads involved or the buffer
functionality being extended, the following problems arise (see Figure 3-7):
1. Even if the notifying thread calls notify only when the condition to
proceed is OK for the waiting thread, the condition may again not be true
when the waiting thread is continuing! Assume we have one producer P
and two consumers C1 and C2, using the Buffer like:
• C1 tries to fetch an object, but gets blocked on since the buffer is
empty.
• P posts an object to the buffer, and since the buffer was empty
that results in a notification of C1 that is moved from the condition
queue to the monitor queue.
• Before C1 is scheduled for execution, that is, before C1 actually
enters the exclusive area, C2 (having a higher priority) continues
(for example after a sleep that was completed after a clock interrupt)
and tries to enter the monitor. If this happens before P has
left the exclusive area, both C1 and C2 are blocked in the monitor
queue. (C1 about to continue after wait, but C2 first in the queue
due to higher priority.)
• When P leaves the monitor, there are one object in the buffer. C2
enters the exclusive area, gets the object, and when leaving C1 is
moved to the ready queue of the scheduler and is allowed to enter
the monitor (owning the lock).
77