JAVA-BASED REAL-TIME PROGRAMMING

3.2. Resources and mutual exclusion – Semaphores
subclassing Thread or by implementing the Runnable interface which simply
states the presence of the run method:
public interface Runnable {
void run();
}
When implementing Runnable you need to call Thread.currentThread() to get
to the public non-static methods of class Thread, which in short includes the
following:
public class Thread implements Runnable {
}
static int MAX_PRIORITY; // Highest possible priority.
static int MIN_PRIORITY; // Lowest possible priority.
static int NORM_PRIORITY; // Default priority.
Thread(); // Use run in subclass.
Thread(Runnable target); // Use the run of ’target ’.
void start(); // Create thread which calls run.
void run() {}; // Work to be defined by subclass.
static Thread currentThread ();// Get currently executing thread.
void setPriority(int pri); // Change the priority to ’pri ’.
int getPriority (); // Returns this thread’s priority.
static void sleep(long t); // Suspend execution at least ’t’ ms
static void yield(); // Reschedule to let others run.
void interrupt(); // Set interrupt request flag.
boolean isInterrupted (); // Check interrupt flag of thread obj.
static boolean interrupted (); // Check and clear for current thread.
boolean isAlive(); // True if started but not dead.
void join(); // Waits for this thread to die.
void join(long t); // Try to join , but only for ’t’ ms.
Note that the Thread class does not relate to real time. Instead, the realtime
clock is, as mentioned, obtained by calling System.currentTimeMillis(); which
returns the value of the real-time clock as a long expressed in milliseconds.
See the JDK class documentation for further information.
3.2 Resources and mutual exclusion – Semaphores
Semaphores are of interest as a basic mechanism that is available in one form
or another in all (?) operating systems and real-time kernels. In some industrial
systems, the only available mechanism is semaphores, on which other
concepts could be built. Also historically, the semaphore was the first (introduced
by Dijkstra in 1968) principle for efficiently handling mutual exclusion
and synchronization, solving problems such as the bank account transactions
described earlier.
A Semaphore is a mechanism that can be used for implementation of the
fundamental abstractions shown in the previous chapter. Such a mechanism
55