JAVA-BASED REAL-TIME PROGRAMMING

2.4. Concurrency
Behind the term concurrent programming is the fact that our software
has to handle concurrently occurring external events. But before making a
definition of the term, let us review some alternative approaches to handle the
situation.
2.4.1 Event processing
In the simplest case, each input event can be immediately and fully handled
before any following events must be taken care of. Then our program may
consist of only data structures, so called event handlers which perform the
processing of each event, and a so called dispatcher that calls the appropriate
event handler for each incoming event. There would, for example, be one event
handler taking care of mouse clicks which then would result in changes of the
data structures, usually reflected on the screen. The dispatcher is called in a
simple loop which thereby is ‘driving’ the application.
The loop retrieving the events (or messages) and calling the handlers is (in
Microsoft terms) called the message pump. When programming user interfaces
using popular class libraries like MFC (Microsoft Foundation Classes), AWT
(the Java-based Abstract Window Toolkit providing an interface to native
graphics and window systems), or JFC (Java Foundation Classes, now known
as Swing), the message pump is hidden inside the class library. Application
programming then means writing the event handlers/listeners and registering
them to the system.
Event processing is easy to program but in most applications, and particularly
in control applications like our LEGO-machine, this execution model
alone is not sufficient. The reasons are:
• Our single control loop will consume all available CPU time for the
successive testing (called polling, or busy wait if nothing else is being
done). This is waste of processing power which prevents the computer
from simultaneously being used for other tasks.
• Most control functions, but not this one, need a notion of time to work
correctly. For example, if there would have been disturbances on our
measurement signal, or if we would need to predict the temperature
some time ahead, sampling and computing would require proper and
known timing
The straightforward solution now is to convert our control function into a
form suitable for event processing, and to have control events periodically
generated with a certain time period. This is actually a useful method for
very small software systems, like software for so called micro-controllers. For
our example application this means that we should:
23