JAVA-BASED REAL-TIME PROGRAMMING

3. Multi-Threaded Programming
the time of sampling it should be correctly packaged in a single object, which
the inValue method (in this case) should return. From a software point of
view we will later work with such objects (of type RTEvent), but creating that
object in this example typically requires native or hardware support depending
on the system and its timing requirements. In a pure Java and concurrent
setting, some improvements can, however, be made. For example the clock
can be read before and after sampling:
1 long timestamp , t0, t1; float x;
2 do {
3 t0 = System.currentTimeMillis ();
4 x = inValue();
5 t1 = System.currentTimeMillis ();
6 } while (t1-t0 > eps); // eps is small , possibly zero.
7 timestamp = (t0+t1)/2; // Statistical improvement.
The disadvantage is that on a heavily loaded system, with certain scheduling,
it can take a quite long time until the do-loop finishes. Limiting the looping
by using a for-statement instead would be another solution which can easily
be accomplished by the reader.
Despite the ideal setting of this example, we found all these problems.
With measurement noise and input value quantization the situation gets even
more severe.
3.1.3 Sleeping
By replacing the comment /*Busy waiting.*/ in the above example with a call
to sleep(1) (defined in class Thread), the efficiency issue is solved. The purpose
of sleep is to provide a way of informing the scheduler that other threads may
run during that long time from now, and that the calling thread should not be
rescheduled for execution within that time. By calling for instance sleep(500),
a minimum discrete time delay of 500 is obtained, which means (due to the
quantization in time as described above) a continues/real-time delay that is
greater then (but not equal to) 499 ms.
Assume you want to do something approximately every new second, such
as updating a progress bar while downloading a file from Internet. We may
have a piece of code like
1 long t, t0 = System.currentTimeMillis ();
2 while (!transferFinished ()) {
3 t = System.currentTimeMillis ();
4 displayProgress(t0, t);
5 Thread.sleep (1000);
6 }
If this code is in a subclass of Thread, the Thread qualification before sleep can
of course be omitted. Since sleep is a static method, it can be called without
having an instance of a thread object. In fact, even if you have a thread object
threadOne, and call threadOne.sleep(1000) from another thread object (or any
object), the calling thread (i.e., the thread of execution, not the thread object)
will be put to sleep while threadOne is not effected. This is because sleep
46 2012-08-29 16:05