JAVA-BASED REAL-TIME PROGRAMMING

the run-time system (that is, the scheduler) what work should be done first,
and what activities that can wait.
Consider the (so far most common) case with a single processor, and compare
with every-day life at home, in school, or at work. Being just one person
but with many things to be done, is a situation that all readers should be
familiar with. People differ in their principles of ’what to do first’; they are
using different sorts of scheduling. The same applies to operating systems. In
both worlds, the way of selecting ’what to do next’ is closely related to the
externally experienced properties of the person/system. Doing the right thing
first is often more important than doing it in a superior way.
For now, we restrict the discussion to a single multi-threaded application
running on one JVM. For embedded computers, that corresponds to the
software running on one processor, not necessarily using a JVM since cross
compilation is often more efficient but from a programming point of view that
does not matter. Thus, we need some method to inform the scheduling (in
the OS, RTOS, kernel, or JVM) about the preferences of our application.
Expressing importance
In a company you may hear things like: "This is a high priority project...", "We
have to put priority on...", or "That bug has to be fixed, with the highest priority.".
Likewise, the by far most common way to influence the scheduling in
operating systems is via priorities. Since Java is designed to be portable, providing
the ability to set priorities on threads is a natural and understandable
choice.
In the java.lang.Thread class there are set- and get-methods for the priority
of the thread. Additionally, there are three integer constants named
MIN_PRIORITY, NORM_PRIORITY, and MAX_PRIORITY, which can be use to set typical
levels of importance. The actual values of these constants are not defined
and the number of priority levels are not defined either in the Java specification;
you can only assume that
MIN_PRIORITY < NORM_PRIORITY < MAX_PRIORITY.
The rest is up to each platform and Java implementation. On, for instance,
Solaris the constants have values 1, 5, and 10 respectively. Thus, a higher
number means a higher priority. A new thread by default gets the priority
NORM_PRIORITY but that is not required in any standard. A thread created in a
Applet, or the main thread of the applet, can only get priorities in the range 1
to 6 as defined for that ThreadGroup (refer to the Java API documentation,
thread groups are omitted here) which is to ensure that the host application
running the applet (typically the web browser) will not be disabled (starved
in terms introduced later) by an applet consuming all of the CPU power.
The lack of a well defined meaning of priorities in Java may give the
impression that they are almost useless. We should, however, be aware of:
3.1. Threads
49