Contents. G53SRP: Java Threads. Definition. Why we need it. A Simple Embedded System. Why we need it. Java Threads 24/09/2009 G53SRP 1 ADC

Size: px

Start display at page:

Download "Contents. G53SRP: Java Threads. Definition. Why we need it. A Simple Embedded System. Why we need it. Java Threads 24/09/2009 G53SRP 1 ADC"

Shanon Maxwell
5 years ago
Views:

1 Contents G53SRP: Java Threads Chris Greenhalgh School of Computer Science 1 Definition Motivations Threads Java threads Example embedded process Java Thread API & issues Exercises Book: Wellings 1.1 & 2; Burns & Wellings Chapter 7.1, 7.3.7, & 7.4 See web page for exercises 2 Quote: Definition Concurrent programming is the name given to programming notation and techniques for expressing potential parallelism and solving the resulting synchronization and communication problems. Implementation of parallelism is a topic in computer systems (hardware and software) that is essentially independent of concurrent programming. Concurrent programming is important because it provides an abstract setting in which to study parallelism without getting bogged down in the implementation detials. (Ben-Ari M., 1982, "Principles of Concurrent Programming", Englewood Cliffs NJ: Prentice Hall). Why we need it To fully utilise the processor To express potential parallelism so that more than one processor can be used to solve the problem To model the parallelism in the real world Virtually all real-time systems are inherently concurrent devices operate in parallel in the real world 3 4 A Simple Embedded System Thermocouples Switch Heater Screen T S Overall objective is to keep the temperature and pressure of some chemical process within well-defined limits P DAC Pressure Transducer Pump/Valve 5 Why we need it The alternative is to use sequential programming techniques - cyclic execution of a program sequence to handle the various concurrent activities complicates the programmer's task The resulting programs will be more obscure and inelegant Decomposition of the problem is more complex Parallel execution much more difficult to achieve Placement of code to deal with faults is more problematic 6 G53SRP 1

2 Elements of concurrent programming Expressing: potential concurrency Processes, threads, coroutines, PAR, Synchronization/concurrency control Locks, semaphors, monitors, Communication Communication Shared memory, message passing, RPC, Threads = Virtual processor UNIX process Light-weight thread (e.g. Java) Sequential Execution state CPU registers (PC, SP, etc.) Stack (procedure arguments, local variables) Can share memory through object references Scheduled by runtime system/os (see later notes) 7 8 Processes versus Threads Threads Fibres Process thread library Operating System Java Concurrency Model (i) Java supports threads Threads execute within a single JVM Native threads map a single Java thread to an OS thread Green threads adopt the thread library approach (threads are invisible to the OS) On a multiprocessor system, native threads are required to get true parallelism (but this is still implementation dependent) 9 10 Java Concurency Model (ii) Integration with OOP, various models: asynchronous method calls early return from methods futures active objects Java adopts the active object approach i.e. an object which can have activity independent of the rest of the application java.lang.thread = JVM-provided Active Object Each instance is/has one thread Executes therun() method in a new thread when start() is called Thread ends whenrun() completes (returns) Concurrent code specified by either Subclassing Thread and overriding run() or Implementing java.lang.runnable (defining run()) ) and passing tothread constructor G53SRP 2

3 Threads in Java java.lang.thread Thread() Thread(Runnable target) void start() { MyThread parameter to MyRunnableObject { subclass association implements java.lang.runnable (interface) Simple Test: what will they print? public class Print10 extends Thread { public { // overriden for (int i=0; i<10; i++) { System.out.println(i); try { sleep(1000); catch (InterruptedException ie) { (b) new Print10().run(); new Print10().run(); (a) new Print10().start(); new Print10().start(); Andy Wellings Switch Heater Concurrency Example Thermocouples Screen T S Overall objective is to keep the temperature and pressure of some chemical process within well-defined limits P DAC Pressure Transducer Pump/Valve 15 Sequential solution (Java pseudo-code) // heater // value 16 Sequential solution notes Temperature and pressure readings are made at the same rate Could do ratios of rates if using counters and if blocks around each Delays in reading/setting temperature delays responses to pressure (and vice versa) Failure (indefinite postponement) of any operation prevents any further action 17 Concurrent solution (Thread) (Java pseudo code) public class HeaterController extends Thread { public { public class ValueController extends Thread { public { new HeaterController().start(); new ValveController().start(); 18 G53SRP 3

4 Concurrent solution (Runnable) (Java pseudo code) Concurrent solution (anonymous subclass) (Java pseudo code) new Thread() { public class HeaterController implements Runnable { public { public { public class ValueController implements Runnable {.start(); public { new Thread() { public { new Thread(new HeaterController()).start(); new Thread(new ValveController()).start(); start(); Other java thread operations Thread.sleep(int ms) calling thread waits for time (at leastms) to pass t.join()/(int(int ms) wait forttoto finish; optionally give up waiting after ms Thread.currentThread() - return reference to thread executing that call t.interrupt() interrupt (next) blocking operation in that thread (see later in course) t.stop() terminate thread deprecated (unsafe) do not use 21 Java thread class class Thread implements Runnable { /* static methods - apply to current thread */ public static native Thread currentthread(); /* allow another thread to run (non-preemptive) */ public static native void yield(); /* pause thead for at least this long */ public static native void sleep(long millis) throws InterruptedException; /* constructors (there are many others) */ public Thread(); public Thread(Runnable target); /* start thread executing */ public synchronized native void start(); /* over-ridenriden function to execute (else calls run() on target) */ public ; 22 /* stop deprecated */ public final void stop(); /* started and not yet stopped */ public final native boolean isalive(); /* interrupt thread, e.g. in wait, sleep */ public void interrupt(); /* pause and resume execution deprecated */ public final void suspend(); public final void resume(); /* properties */ public final void setpriority(int newpriority); public final int getpriority(); public final void setname(string name); public final String getname(); public final ThreadGroup getthreadgroup(); /* Daemon = service thread: application will not wait for a daemon thread to exit */ public final void setdaemon(boolean on); public final boolean isdaemon(); More about Java thread An application exits when all it has no non- daemon threads alive (seesetdaemon). Each thread has a priority which represents its importance or urgency (see setpriority) ) (more later in the course). Java garbage collection is typically implemented as a low priority thread. Each Java thread also belongs to a thread group. /* wait for thread to finish */ public final synchronized void join(long millis) throws InterruptedException; G53SRP 4

5 Other Java Thread issues Preemption/time-slicing of busy threads Not implemented in all JVMs Else requires cooperative multitasking (e.g. calls tothread.sleep(0) Thread.sleep(0)). ). Resource Requirements Stack (native & Java) E.g. ~128MB virtual memory per thread Seejava.nio for newer non-blocking IO options (need fewer threads, e.g. for large web servers) 25 Summary: Java thread states Java thread life-cycle: new Thread() sleep(0) start() Blocked/ [New] [Runnable] [Not Runnable] stop() stop() or stop() run() exits [Dead] 26 Summary (ii) Concurrently executable code expressed as run() method ofrunnable orthread Executed concurrently by a Thread object afterstart() Runs to completion unlessstop() stop()ed or destroy()eded (deprecated) Blocked bysleeping, I/O, locking, wait, join 27 G53SRP 5

Object Oriented Programming. Week 10 Part 1 Threads

Object Oriented Programming. Week 10 Part 1 Threads Object Oriented Programming Week 10 Part 1 Threads Lecture Concurrency, Multitasking, Process and Threads Thread Priority and State Java Multithreading Extending the Thread Class Defining a Class that