JAVA-BASED REAL-TIME PROGRAMMING

3.1. Threads
first obtains the currently executing thread, which you can also do by calling
Thread.currentThread(), and then that thread (the caller of course) will sleep.
In other words, Thread.sleep(t) is the same as Thread.currentThread().sleep(t),
and a thread can put itself to sleep but cannot put another thread to sleep. If
that should have been possible, certain restrictions on run-time systems and
code optimizations would need to be imposed, resulting in decreased (possible)
performance.
Note that sleep(1000) above does (in most cases) not give an update every
second; the 1000 is a minimum sleeping time but there is no strict upper limit.
The actual time before execution continues after sleep typically depends on
the processor load. Furthermore, the sleeping for 1000 ms is from the time
that called starts executing in the JVM or OS with interrupts disabled. Any
time increments before then results in that much longer period of time for
the update. Most often, especially in control applications, it is a periodic
behaviour that is desired.
We have a similar situation if we in our example wants to call displayProgress
every second. Still we do not impose any upper limit on the waiting for each
new second (which would be a real-time requirement), we just require no
long-term drift as long as the computer is not permanently overloaded. This
is accomplished in the following:
1 long t, t0, diff;
2 t = t0 = System.currentTimeMillis ();
3 while (!transferFinished ()) {
4 displayProgress(t0, t);
5 t += 1000;
6 diff = t - System.currentTimeMillis ();
7 if (diff > 0) Thread.sleep(diff);
8 }
Note that t now is ideal, not reflecting temporary excessive delays. To
facilitate implementation of periodic activities, there should of course have
been a method sleepUntil in class Thread, but there is not. Even if it can
be emulated as shown, an increment of the real time after assignment of diff
but before calling sleep results in a requested sleeping time that is too long.
That does not really matter since we can be delayed after the sleeping anyway.
(But from a real-time systems point of view, it would be preferable to correctly
inform the real-time scheduling.)
3.1.4 Race conditions
Knowing how to create multiple threads, let us make a multi-threaded version
of the standard HelloWorld program. Consider the following example (where
exceptions have been omitted for clarity):
class HelloWorld extends Thread {
public static void main(String[] arg) {
System.out.print("Hello ");
new HelloWorldApp ().start();
sleep(1);
47