JAVA-BASED REAL-TIME PROGRAMMING

3. Multi-Threaded Programming
1. The correctness of our software, except for timing which is what priorities
are for, should never depend on priorities. For instance, it should
be considered as an error to accomplish mutual exclusion by utilizing
the knowledge that one thread will have a higher priority than another.
Even if that always is the case, there is no guarantee that priorities are
strictly obeyed on all platforms. That is, using an RTOS a higher priority
thread always given precedence in favor of a low priority thread, but
on Solaris, Linux, Windows, and other desk-top and server platforms,
you cannot know. Those types of systems are optimized for overall performance
and can in principle not be trusted for hard real-time systems.
So, if embedded software requires a certain RTOS anyway, additional
requirements on the number of priorities etc. go along the the system
requirements. Still, the logical and concurrent behavior of the system
should remain on any Java-enabled platform.
2. An application that depends on scheduling principles and the number
of priority levels can obtain the type of OS and other properties at
run time (e.g., by calling System.getProperty(“os.name”);), and behave
accordingly. A OS-dependent but portable application simply has to
cope with reality (rather than Java principles).
3. Priorities are managed globally for the software application and they
influence the global properties of the system. However, a certain thread
created in a class library or in a third-party component too often gets a
(usually hard-coded) priority that does not suit the rest of the system.
Furthermore, the desired system properties are not necessarily easy to
express using priorities. Response time, control performance, quality
of service, etc. are more related to end-user values. Obtaining priorities
from such properties is outside the scope of this chapter. Another
approach would be to have a real-time platform with built-in timing
and/or performance optimization, perhaps not using priorities at all.
The classical approach, found in almost any OS is to use priorities, and
that is also what Java provides. The ability to run the software on any
Java platform is a must. Therefore, additional supporting classes are
needed for implementation of real-time systems, but for now we stay
with multi-threaded programming and the standard and portable Java
features.
The conclusion is that priorities, as defined in Java, are useful for simple
tuning of application performance and responsiveness, but for large-scale realtime
systems we need additional supporting classes but that is a later issue.
50 2012-08-29 16:05