JAVA-BASED REAL-TIME PROGRAMMING

More documents

Recommendations

Info

3. Multi-Threaded Programming with the programmed system calls. The correct result may depend on time, and different actions could be taken depending on time, but there is no guarantee concerning the time of execution. • Specifically, priorities are suggestions for the scheduling (and thereby the timing) but the correctness may not depend on priorities. Furthermore, waiting a specified time (sleep) or until a specified time (sleepUntil) only means that execution is suspended for at least that long. That permits the scheduler to have other threads running during the specified amount of time, but the software alone does not specify any upper limit of the real-time delay. These are basically the preconditions for the Java platform. It agrees well with concurrency for Internet applications; the network exhibits unpredictable timing anyway. It also agrees with the properties of the most well-known operating systems such as Unix (Solaris, Linux, etc.) and Windows-NT. With no further assumptions, our concurrent system is not a real-time system. (By simulating the environment we can, however, simulate a real-time system and carry out almost all of the software test and debugging.) Hence, multi-threaded programming (i.e., concurrent programming based on threads) should therefore not be confused with real-time programming which we will cope with in later chapters, just a few further comments here: In order to obtain correctness from a real-time point of view, a concurrent program has to be run on a real-time platform. Such a platform must fulfil additional requirements concerning CPU-speed, available memory, IO and interrupt handling, scheduling algorithms, and the input to the scheduler from the application software. Even on a non-real-time platform we may obtain a system behaviour that appears to be real-time. A common approach, for instance when using PCs in industrial automation, is to only let one or a few well-known programs/daemons/ services run, to have some activities run in some kind of kernel or driver mode, to tailor the application software for improved handling of sporadic delays (for instance by temporarily adjusting parameters and decrease performance), and by using a powerful computer. Still, since the system is not guaranteed to produce a quite correct result at the right time, it is not real time. But from an application point of view, the system behaviour can be good enough. Therefore, in a practical industrial context the borderline between real-time and concurrent programming is not that clear. 3.1 Threads For now we assume that our concurrent activities can run independently of each other, with no need for synchronization and mutual exclusive methods. 42 2012-08-29 16:05
3.1.1 Thread creation At start of a Java Virtual Machine (JVM), the so called main thread starts executing the Java program by calling the main method of the class given to the JVM. In case of an applet, the same applies but then the main method is part of the host application, which in turn calls the applet’s init method. To have another thread running, a system call has to be done (within the JVM or to the OS, at this stage we don’t care which). In most programming languages there is no built-in support for concurrency, and creating new threads has to be done via a platform and language specific system/ library call. In the Java platform, we have to create an object of type java.lang.Thread and call its method start (which is native, i.e., not written in Java). The caller of start returns as for any method call, but there is also a new thread competing for CPU time. The newly created thread must have an entry point where it can start its execution. For this purpose there must be a runnable object available to the thread object. A runnable object provides a method run according to the interface java.lang.Runnable; that interface simply declares a public void run() and nothing more. It is that run method you should implement to accomplish the concurrent activity. What run method to be called by start is determined at thread-object creation time, i.e., when the thread object constructor is run. There are two alternatives depending on what constructor that is used, extending a thread object or implementing a runnable object: • By extending class Thread, Runnable will be implemented since public class Thread extends Object implements Runnable. In other words, this will be an instance of Runnable. The default constructor will select this.run as the beginning for the new thread. Advantages with this alternative is that you can override also the start method (to do some things before/after thread creation/termination, calling super.start in between), utility methods of class Thread can be called without qualification and asking the run-time system for the currently executing thread (described in the sequel), and the inheritance is a good basis for developing further threading subclasses (as done in later chapters). • By implementing the Runnable interface, the object can be passed to the Thread constructor which then will use the run of the supplied object as the beginning for the new thread. The advantage with this approach is that the (in Java single) inheritance can be used for other purposes, such as inheriting graphical properties. In short, as indicated in the second item, which alternative that is most suitable depends on the primary issue of the software. For instance, a graphical 3.1. Threads 43
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: Chapter 3 Multi-Threaded Programmin
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 and 54: • If the operation of an industri
Page 55 and 56: 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?