JAVA-BASED REAL-TIME PROGRAMMING

2.6. Models of concurrent execution
embedded systems, thread objects provide almost the same execution
efficiency. The major reasons for omitting the coroutines in the Java
language are: 1) The language can be kept simpler. 2) Most programmers
do not know how to utilize coroutines anyway, particularly not in
combination with threads. 3) Having the programmer to use threads
instead means that the run-time system is free to let activities run in
parallel if there are multiple CPUs available.
• The threads are based on so called native methods, i.e., functions that
are implemented external to the JVM. In the case of thread support,
native methods may be implemented by the operating system. Thread
creation, interaction, and scheduling are then handled by the system
functions which are optimized for the actual hardware used (and run in
parallel as mentioned in the previous item). Of course there is a lack of
elegance compared to a system based on coroutines, having the scheduler
implemented as in the language itself. However, for the majority of applications
running on an operating system such as the Solaris operating
system (the Sun UNIX which supports up to 64 processors), using the
native threads boosts performance (without changing the source code).
In conclusion, Java provides passive objects and active objects. A passive
object is either an ordinary object, or it can be an object with no data exposed
and all methods synchronized which then functions like a monitor. There
are, however, no real monitors in the language; the programmer may expose
data to concurrent access and some methods may be left unsynchronized.
Active objects are those with the thread property, but we do not have (and
we will not talk about) tasks since we do not have threads with implicit mutual
exclusion. We will therefore only speak about classes, objects, synchronized
methods, and threads. These are our building blocks for concurrent and realtime
programming. There is, however, very little support for handling timing
requirements, which we will return to in the final chapters.
2.6.3 Processes and interrupts
In the above treatment of programming language support for concurrency,
we neglected two aspects, processes and interrupt service routines. In short, a
process is the type of concurrent execution we have when we run some program
under an operating system such as UNIX or Windows NT, and an interrupt
service is the concurrent execution we have when a hardware interrupt starts
a new thread of execution. These have to do with the interaction between the
Java program and its environment in terms of hardware or other programs.
Since this is quite dependent of the specific environment, it is probably a good
idea not to provide any language support. Instead, we use classes that provide
certain programming interfaces. Here, we will use the term interrupt to denote
the execution carried out to service the actual hardware interrupt.
35