JAVA-BASED REAL-TIME PROGRAMMING

Object properties Implicit mutual exclusion of methods
Thread Exec. state No Yes
2.6. Models of concurrent execution
Comment
No No Object Monitor Passive objects
No Yes Coroutine ’Co-monitor’ Not in Java
5 6
Yes No — —
Not useful
7 8
Yes Yes Thread-object Task Active objects
Figure 2.3: Fundamental properties of software execution. Language support
for an execution property is marked with “yes”. For mutual exclusion to be
supported, it must be implicitly obtained from the types or declarations.
at a time may run the code of the object. This abstraction is called a
monitor.
3. Having an execution state without having a thread permanently associated
with it forms an abstraction called a coroutine. A coroutine must
be used by a thread to advance its execution state. If you have multiple
coroutines but only one thread, only one coroutine at a time may
execute. This is useful to handle parallellity issues in algorithms or in
simulations because there the (virtual) time of the model can be held or
advanced arbitrarily. That is, the real time used by a specific thread for
its execution is unimportant, and a single thread using multiple coroutines
is appropriate. An implementation based on coroutines can always
be rewritten to work without them, but that may require more complex
data structures and code. In combination with timer interrupts triggering
a scheduler, coroutines can be used to implement thread objects.
4. Adding mutual exclusion to coroutines is not really necessary in the case
of just one thread, and in the case that a group of coroutines run by one
thread interacts with other threads, this alternative leads to difficult and
error-prone programming. The name co-monitor is not established and
this case is neither used nor commented in the sequel.
5. A thread without an execution state cannot execute on its own, and
borrowing another thread for its execution does not provide concurrency.
This case it therefore not useful.
6. Also with mutual exclusion, this case is not useful for the reasons mentioned
in item 5.
7. An object with both thread and execution state is capable of execution of
its own. We call this an active object or a thread object. The problem is
that access to the attributes requires explicit mutual exclusion. That has
to be simple to express in the program in order to make this alternative
1
3
2
4
33