1 Ivan Marsic Rutgers University LECTURE 19: Concurrent Programming

2 Topics  Threads  Exclusive Resource Access –Exclusion Synchronization  Cooperation between Threads –Condition Synchronization  Concurrent Programming Example

3 Parallelism  What we want: Parallel instead of serial processing, to speed up service  What problems to solve: Concurrent access to a resource (or software object) can lead to conflict  ambiguous result or “frozen” program

4 Concurrency: Exclusion Synchronization

5 Thread vs. Process  Process roughly corresponds to a program (* program can “spawn” many processes )  Processes communicate using inter- process communication (pipes, sockets, shared memory, …) –An object from one process cannot directly call a method on an object shared by another process  Threads run in the same program –An object from one thread can directly call a method on an object shared by another thread

6 Concurrent Programming -- Threads Lifecycle of Java threads

7 Thread States: Alive  Alive: After a thread is start() -ed, it becomes alive: –Runnable: The thread can be run when the OS scheduler can arrange it (and nothing prevents it from being run) –Blocked: The thread could be run, but there is something that prevents it (e.g., another thread is holding the resource needed for this thread to do its work). While a thread is in the blocked state, the scheduler will simply skip over it and not give it any CPU time. A thread can become blocked for the following reasons: Waiting for notification: Invoking the method wait() suspends the thread until the thread gets the notify() or notifyAll() message Waiting for I/O or lock: The thread is waiting for an input or output operation to complete, or it is trying to call a synchronized method on a shared object, and that object’s lock is not available Waiting for rendezvous: Invoking the method join(target) suspends the thread until the target thread returns from its run() method Sleeping: Invoking the method sleep(milliseconds) suspends the thread for the specified time

8 Exclusion Synchronization

9 Example: Bank Account Access by Two Users  Concurrent read/write of the same data by several threads  “race condition” or “race hazard”  The outcome of the execution depends on the particular order in which the access takes place Thread 1 Thread 2 oldBalance = account.getBalance();... newBalance = oldBalance + deposit; oldBalance = account.getBalance(); account.setBalance(newBalance); newBalance = oldBalance - withdrawal;... account.setBalance(newBalance);

10 Exclusion Synchronization in Java public class SharedClass {... public synchronized void method1(... ) {... } acquire lock release lock shared object public class AnyClass {... public void method2(... ) {... synchronized (expression) { statement }... } acquire lock release lock shared object Synchronized MethodsSynchronized Statements (a)(b)

11 Condition Synchronization suspend and wait … … resume the suspended work

12 Example: Safe Home Access Backyard door: Access lock Front door: Access lock Central Computer

13 Example of Concurrency Gains Single thread – sequential service (a) Multiple threads – parallel service (b)

14 Where Latency Matters?  While typing in the digits, the user does not notice latency  Latency becomes noticeable when waiting for validity check and device activation  Validity computation is quick; device activation may be somewhat slower  The longest latency is while the user is typing-in the keycode so we need to allow parallel entry of keycodes on both doors  But...all communication goes over the same serial cable: Tenant Read Digits [ keycode valid ] [else] Check Validity Activate Devices [ keycode complete ] [else]

15 Hardware Implementation NOTE: Locks, lightbulb switch (with photosensor) and alarm bell are controlled by the central computer via the same serial port

16 Multithreaded Implementation keyFront : StringBufferkeyBack : StringBuffer contrlBack : ControllerThdcontrlFront : ControllerThd HomeAccessControlSystem_2x + serialEvent(event : SerialPortEvent) Main Thread: interacts with serial I/O port Helper Thread: back door calculations and control Helper Thread: front door calculations and control Shared Object ( See Listing 5-6 in the book for details )