JAVA-BASED REAL-TIME PROGRAMMING

3. Multi-Threaded Programming
To improve on these aspects, communication via messages (instead of via
methods and shared data) will be introduced in this section. Originally and
traditionally, this was referred to as mailboxes.
From one point of view, a so called mailbox is nothing but a special type of
monitor, so we do not need any additional support from the language (no new
keywords like synchronized which supports monitors). From another point of
view, when the above aspects are important, message based object interaction
can be considered to be fundamental, so let us start with some considerations
about the abstraction we deal with.
3.4.1 More on object interaction
Method calls in a language/system providing only passive objects are by definition
a synchronous type of communication. That is, passive objects work
synchronously since they share the same thread of execution. In other words,
this type of communication between objects is synchronous since the called
object remains in its well defined state during the data transfer.
During a method call, the caller enters the scope of the method within
the scope of the called object, performing exactly what the method states. In
a single-threaded system this is fine; data access via methods provide encapsulation
and data abstraction. When all objects are executed by the same
thread, we actually do not think of any thread at all. Data is transferred via
arguments and return values, in both directions between the objects, which is
straightforward and efficient in single-threaded applications.
To support multi-threaded applications, the programming language could
provide active (concurrently executing) objects, and models other than method
calls for data transfer between objects. In fact, within object-oriented programming
in general, communication between objects are (as in the language
Smalltalk) often referred to as message passing. In Java, object interaction
stems from the traditional (computationally efficient) C/C++ approach with
method calls which are basically the same as function calls in C. Hence, in
Java as well as in most other languages, asynchronous communication should
be accomplished by a class implementing some type of mailbox or buffer supporting
the principle of message passing.
Thinking about real-life actors, sending a message is a natural way of transferring
information, in particular when the sender and the receiver are acting
concurrently but not synchronized (that is, performing actions independently
of each other). The message need to be temporarily stored (buffered) somehow
after being sent until being received. Today, information is most often stored
and transmitted electronically. On the Internet, messages between humans
are mainly accomplished by e-mail, but in technical systems we also use many
other message principles depending on application and development needs.
86 2012-08-29 16:05