JAVA-BASED REAL-TIME PROGRAMMING

3. Multi-Threaded Programming
class Buffer { // Inefficient!!
synchronized void post(Object obj) {
while (buff.size()>=maxSize) {
wait();
}
buff.add(obj);
notifyAll();
}
}
synchronized Object fetch() {
while (buff.isEmpty()) {
wait();
}
return buff.remove();
notifyAll();
}
class Buffer { // Well done.
synchronized void post(Object obj) {
while (buff.size()>=maxSize) {
wait();
}
if (buff.isEmpty()) notifyAll();
buff.add(obj);
}
}
synchronized Object fetch() {
while (buff.isEmpty()) {
wait();
}
if (buff.size()>=maxSize) notifyAll();
return buff.remove();
}
Figure 3.9: Two alternative implementations of the Buffer class. Declarations,
initializations, and exception handling is omitted as in Figure 3.8.In the left
version, all methods always call notifyAll (does not need to be last), possibly
resulting in performance problems. In the version to the right, robustness and
performance should be acceptable.
wait(long timeout) The thread executing within the monitor temporarily
leaves the monitor, waiting for a notification as normal. If notify is
not called within timeout milliseconds, we give up waiting and return to
the caller anyway. The timeout is minimum value; it can be longer as an
implication of the actual scheduling of involved threads and the internal
timer. A timeout equal to zero is equivalent to calling wait without any
timeout argument. A negative timeout results in an IllegalArgumentException.
wait(long timeout, int nanos) The same as previous wait but with the timeout
time set to 1000000*timeout+nanos nanoseconds. Again, this is a
minimum time that depends on the actual scheduling, if the resolution of
time in our runtime system is high enough. However, with ms resolution
or lower, the nanos are rounded to the nearest ms (!) which implies that
the minimum timeout time can be up to 0.5 ms shorter than requested,
but not shorter than the timeout since that value is rounded upwards if
the clock resolution is lower than 1 ms.
Note the difference between calling java.lang.Thread.sleep(delay) from within
a monitor, and calling java.lang.Object.wait(delay). The former keeps the
monitor locked during waiting/sleeping, whereas the latter lets other threads
access the monitor during the delay time. It is, however, difficult to ensure that
wait(delay) actually delays for at least delay ms since notify in other methods
80 2012-08-29 16:05