JAVA-BASED REAL-TIME PROGRAMMING

3. Multi-Threaded Programming
requires certain features from the operating or run-time system, and cannot be
purely implemented in, for instance, Java without help from native systems
calls. Therefore, the semaphore methods we are about to introduce should
be considered as system calls (part of the operating or runtime system) with
certain properties, not to be confused with ordinary methods that can be
implemented on the Java level.
We may, on the other hand, be able to implement semaphores in Java
if we can use some built-in or native Java feature (synchronized methods
in this case) to accomplish suspension of execution until certain conditions
are fulfilled. Alternatively, some way of implementing atomic methods could
be available (such as native methods for disabling and enabling interrupts).
An atomic method is a method that cannot be interrupted by execution of
other parts of the software. Anyhow, no matter how we implement semaphore
mechanism, natively or built on some Java feature, we think of the methods
as atomic and with properties according to the sequel.
3.2.1 Semaphore methods
Recall that semaphores are the primary mechanism in many small embedded
systems, so we need semaphore classes that model the semaphore concept and
supports cross compilation to native code. Linking with native implementations
of semaphores as provided in most real-time kernels then permits full
efficiency also when special hardware is used. To this end, let us first study
the concept and then look into the implementation.
Core operations
A semaphore is basically a non-negative integer-valued counter with two atomic
methods and a queue for blocked/waiting threads. The methods (with return
type void) of interface Semaphore are:
take(); decrements the counter if it is positive, but if the counter is zero,
execution of the caller is suspended and that thread is put in some kind
of queue waiting for the counter to become positive. Hence, an operation
that increments the counter must check the queue and wake up the first
thread.
give(); increments the counter and checks if there are any threads waiting in
the queue. If so, a thread is made ready for execution, which can resume
when the caller of give has completed its (atomic) call of give.
Apart from some initialization of the counter when the semaphore is created/initialized,
these two methods are the only two methods available according
to the original definition. When a blocked thread is placed in the waiting
56 2012-08-29 16:05