JAVA-BASED REAL-TIME PROGRAMMING

More documents

Recommendations

Info

3. Multi-Threaded Programming ’coma’; alive sleeping until the death, unless interrupted which will permit recovering. • Joining a thread object that has not been started returns directly (without errors) since it is not alive (yet). In practice, in your own code if you are aware of the limitations, thread termination is not a problem. To specify a time-out for joining a thread, there are versions of join with time-out arguments. Inappropriate thread methods Among the useful and well designed methods of class Thread, there are also some ’features’ that resembles ’bugs’ and should be avoided. First there is a method destroy which is supposed to actually interrupt and kill the thread. However, allocated resources could then not be returned since that (for run-time reasons) has to be done by the thread that is going to be killed. Since destroy most likely would leave the application in a badly working state, it should not be called. It is even written in the Java2 documentation: “This method is not implemented”. There is also a method stop which in the Java2 API documentation is described as “inherently unsafe ..., potentially resulting in arbitrary behavior”. Its purpose is/was to force the thread to stop executing. It is unsafe for the same reasons as destroy is. Actually calling stop will permit some cleanup and return of resources to be done, but that exhibits undefined timing and resource management on the user level cannot (in practice) be handled in a system routine such as stop. In the beginning of the real-time programming subject, students often want to use something like stop (or even destroy) instead of dealing with actual execution and OS properties. It is hard to understand why the Java engineers @sun.com introduced stop in the first place. Finally, there are two methods that could have been useful if designed properly: suspend and resume. The problem is that, as their names suggest, suspending and resuming execution was accomplished as a mechanism well separated from the ordinary thread management. With two unrelated ways of suspending execution, there was a big risk for a set of threads to be (depending on timing) permanently blocked. These methods and their deficiencies are outside the scope of this text. 3.1.7 The Thread class We are now ready to sum up the content of class lava.lang.Thread which in a abbreviated form can be expressed as shown below(all shown members are public which is omitted, and deprecated methods are not shown). The task to be carried out by the thread is implemented in the run method, either by 54 2012-08-29 16:05
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
Page 1:
JAVA-BASED REAL-TIME PROGRAMMING Kl
Page 4 and 5: • Each piece of software must be
Page 7 and 8: Contents I Concurrent programming i
Page 9: Part I Concurrent programming in Ja
Page 12 and 13: 1. Introduction pany depends on the
Page 14 and 15: 1. Introduction control may be dela
Page 17 and 18: Chapter 2 Fundamentals Goal: Review
Page 19 and 20: 2.2. Our physical world is parallel
Page 21 and 22: 2.4. Concurrency a trend that the p
Page 23 and 24: 2.4. Concurrency Behind the term co
Page 25 and 26: 2.4. Concurrency in functions like
Page 27 and 28: 2.5. Interrupts, pre-emption, and r
Page 29 and 30: 2.5. Interrupts, pre-emption, and r
Page 31 and 32: 2.6. Models of concurrent execution
Page 33 and 34: Object properties Implicit mutual e
Page 35 and 36: 2.6. Models of concurrent execution
Page 37 and 38: 2.7 Multi-process programming 2.7.
Page 39 and 40: 2.9. Software issues In this chapte
Page 41 and 42: Chapter 3 Multi-Threaded Programmin
Page 43 and 44: 3.1.1 Thread creation At start of a
Page 45 and 46: to foresee the value actually retur
Page 47 and 48: 3.1. Threads first obtains the curr
Page 49 and 50: the run-time system (that is, the s
Page 51 and 52: 3.1.6 Thread interruption and termi
Page 53: • If the operation of an industri
Page 57 and 58: 3.2. Resources and mutual exclusion
Page 59 and 60: give give give 3.2. Resources and m
Page 61 and 62: synch. T1 entry give take 3.2. Reso
Page 67 and 68: class Account { int balance; Semaph
Page 69 and 70: 3.3. Objects providing mutual exclu
Page 77 and 78: class Producer extends Thread { pub
Page 85 and 86: 3.4 Message-based communication - M
Page 87 and 88: 3.4.2 Events and buffers 3.4. Messa
Page 89 and 90: Real-Time Events - RTEvent 3.4. Mes
Page 91 and 92: 3.4. Message-based communication -
Page 93 and 94: RTEvent post(RTEvent e) final void
Page 95 and 96: 3.4. Message-based communication -
Page 97: 3.4. Message-based communication -
Page 100 and 101: 4. Exercises and Labs 4. In the pro
Page 102 and 103: 4. Exercises and Labs /** * The buf
Page 104 and 105:
4. Exercises and Labs object and gi
Page 106 and 107:
4. Exercises and Labs Excerpt from
Page 108 and 109:
4. Exercises and Labs 4.3 Lab 1 - A
Page 110 and 111:
4. Exercises and Labs Some advice o
Page 112 and 113:
4. Exercises and Labs 4.4 Exercise
Page 114 and 115:
4. Exercises and Labs • CustomerH
Page 116 and 117:
4. Exercises and Labs 4.5 Exercise
Page 118 and 119:
4. Exercises and Labs Lab 2 prepara
Page 120 and 121:
4. Exercises and Labs } /** Draws a
Page 122 and 123:
4. Exercises and Labs public static
Page 124 and 125:
4. Exercises and Labs Specification
Page 126 and 127:
4. Exercises and Labs /** * Turns t
Page 128 and 129:
4. Exercises and Labs your washing
Page 130 and 131:
4. Exercises and Labs } } super(mac
Page 132 and 133:
4. Exercises and Labs } /** * @retu
Page 134 and 135:
4. Exercises and Labs PeriodicThrea
Page 136 and 137:
4. Exercises and Labs Miscellaneous
Page 138 and 139:
4. Exercises and Labs Scheduling wi
Page 140 and 141:
4. Exercises and Labs Getting appro
Page 142 and 143:
5. Solutions 2. With some additiona
Page 144 and 145:
5. Solutions 5.2 Solution to exerci
Page 146 and 147:
5. Solutions class YourMonitor { pr
Page 148 and 149:
5. Solutions 5.4 Solution to exerci
Page 150:
5. Solutions b) After the rewriting
show all

JAVA-BASED REAL-TIME PROGRAMMING

Create successful ePaper yourself

Delete template?

Save as template?