Lecture 10 Multithreading

Transcription

1 Lecture 10 Multithreading

2 Introduction to Threads

3 Threads in Java

4 public class TaskThreadDemo public static void main(string[] args) // Create tasks Runnable printa = new PrintChar('a', 100); Runnable printb = new PrintChar('b', 100); Runnable print100 = new PrintNum(100); // Create threads Thread thread1 = new Thread(printA); Thread thread2 = new Thread(printB); Thread thread3 = new Thread(print100); // Start threads thread1.start(); thread2.start(); thread3.start();

5 // The task for printing a character a specified number of times class PrintChar implements Runnable private char chartoprint; // The character to print private int times; // The number of times to repeat public PrintChar(char c, int t) chartoprint = c; times = t; public void run() for (int i = 0; i < times; i++) System.out.print(charToPrint);

6 // The task class for printing numbers from 1 to n for a given n class PrintNum implements Runnable private int lastnum; public PrintNum(int n) lastnum = n; public void run() for (int i = 1; i <= lastnum; i++) System.out.print(" " + i);

7 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbb bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb bbbbbbbbbbbbbbbbbbbb

8 aabbbb 1 2aaaaa 3 4bbb 5 6a 7 8b a b a b a b 27 28a b 32a 33 34b 35aaaaaaaa36b37aaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaa38bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb b 43b 44b 45bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

9 The Thread Class

10 You could do it...but it would be WRONG! Since the Thread class implements Runnable, you could define a class that extends Thread and implements the run method, as shown in Figure 29.5(a), and then create an object from the class and invoke its start method in a client program to start the thread, as shown. This approach is, however, not recommended, because it mixes the task and the mechanism of running the task. Separating the task from the thread is a preferred design.

11 Sharing Data and Resources Programs executing separate threads running independently are relatively simple to implement and debug. When two or more threads have to access the same memory or share the same resources, the situation becomes much more complicated. Programs that correctly manage multiple threads sharing data and/or resources are said to be threadsafe. The Java environment and its associated libraries provide an extensive collection of thread-safe software tools. Occasionally we are required to build our own multithreaded programs so it is important to become familiar with the programming tools and methods used to support the development of thread-safe applications.

12

13

14

15

16

17

18

19

20 Definition of the Problem We start with a specification of the structure of the critical section problem and the assumptions under which it must be solved: Each of N processes is executing in an infinite loop a sequence of statement that can be divided into two subsequences: the critical section and the noncritical section The correctness specifications required of any solution are:

21 Mutual Exclusion Enforcing mutual exclusion is the method for preventing more than one process or thread from accessing a shared memory space at any given time. In multi-processing and multi-threaded applications, this is needed to ensure that asynchronous operations do not produce inconsistent data. Modern programming languages provide mechanisms for enforcing mutual exclusion. For example C# includes the lock( ) method that can be used to prevent two or more threads from entering a designated critical section of code in which shared memory will be accessed/modified. Unfortunately these machine specific methods cannot be used in distributed applications since there is no way to guarantee that some remote system will support them. What is needed, is a software-only means of enforcing mutual exclusion...

22 Mutual Exclusion: Version 1

23 Mutual Exclusion: Version 2

24 Mutual Exclusion: Version 3

25 Mutual Exclusion: Version 4

26 Mutual Exclusion: Version 5

27 Mutual Exclusion: Version 6

28 N-Process Mutual Exclusion When we consider n processes sharing memory rather than just two, the problem of mutual exclusion becomes much more complex. An efficient software-only algorithm for enforcing mutual exclusion among n process was developed by L.Lamport in which each process must take a ticket or be placed in a queue to wait for access to shared memory. This method is called Lamport s Bakery Algorithm and is particularly well suited to distributed 42? number 42? Compare Lamport's Bakery Algorithm to Dekker's or Peterson's Algorithm. How are they different. What do we gain by using Lamport's Algorithm? What do we give up?

29 Introduction Deadlock A process or thread is waiting for a particular event that will not occur System deadlock One or more processes are deadlocked

30 Simple Resource Deadlock Resource deadlock example. This system is deadlocked because each process holds a resource being requested by the other process and neither process is willing to release the resource it holds.

31 Four Necessary Conditions for Deadlock Mutual exclusion condition Resource may be acquired exclusively by only one process at a time Wait-for condition (hold-and-wait condition) Process that has acquired an exclusive resource may hold that resource while the process waits to obtain other resources No-preemption condition Once a process has obtained a resource, the system cannot remove it from the process s control until the process has finished using the resource Circular-wait condition Two or more processes are locked in a circular chain in which each process is waiting for one or more resources that the next process in the chain is holding

32 Deadlock Prevention Deadlock prevention Condition a system to remove any possibility of deadlocks occurring Deadlock cannot occur if any one of the four necessary conditions is denied First condition (mutual exclusion) cannot be broken

33 Denying the No-Preemption Condition When denying the no-preemption condition Processes may lose work when resources are preempted This can lead to substantial overhead as processes must be restarted

34 Denying the Circular-Wait Condition Denying the circular-wait condition: Uses a linear ordering of resources to prevent deadlock More efficient resource utilization than the other strategies Drawbacks Not as flexible or dynamic as desired Requires the programmer to determine the ordering or resources for each system

35 Denying the Circular-Wait Condition Havender s linear ordering of resources for preventing deadlock.

36 Deadlock Detection Deadlock detection Used in systems in which deadlocks can occur Determines if deadlock has occurred Identifies those processes and resources involved in the deadlock Deadlock detection algorithms can incur significant runtime overhead

37 Deadlock Recovery Deadlock recovery Clears deadlocks from system so that deadlocked processes may complete their execution and free their resources Suspend/resume mechanism Allows system to put a temporary hold on a process Suspended processes can be resumed without loss of work Checkpoint/rollback Facilitates suspend/resume capabilities Limits the loss of work to the time the last checkpoint was made

38 The Dining Philosophers P0 R4 R0 P4 P1 R3 R1 R2 P3 P2

39 A Minimal (Simple) Lock Demo import java.util.concurrent.locks.lock; import java.util.concurrent.locks.reentrantlock; public class SimpleLockDemo private Lock alock; public SimpleLockDemo() alock = new ReentrantLock(); public void callme(int threadnum) alock.lock(); try System.out.println(threadnum + " in critical section"); long starttime = System.currentTimeMillis(); while(starttime+1000>system.currenttimemillis()); finally System.out.println(threadnum + " leaving critical section"); alock.unlock();

40 demorunnable - Can Be Run as a Thread public class demorunnable implements Runnable private SimpleLockDemo simple; private int tnumber; public demorunnable(simplelockdemo ademo, int tnum) simple = ademo; tnumber = tnum; public void run() try for (int i = 1; i <= 10; i++) simple.callme(tnumber); Thread.sleep(20); catch (InterruptedException exception)

41 Main Program - Simple Lock Demo public class SimpleLockDemoRunner public static void main(string[] args) SimpleLockDemo simple = new SimpleLockDemo(); for(int i=0;i<5;i++) demorunnable d = new demorunnable(simple,i); Thread dt = new Thread(d); dt.start();

42 Sample Output 0 in critical section 0 leaving critical section 1 in critical section 1 leaving critical section 2 in critical section 2 leaving critical section 3 in critical section 3 leaving critical section 4 in critical section 4 leaving critical section 0 in critical section 0 leaving critical section 1 in critical section 1 leaving critical section 2 in critical section 2 leaving critical section 3 in critical section 3 leaving critical section 4 in critical section 4 leaving critical section 0 in critical section 0 leaving critical section 1 in critical section 1 leaving critical section 2 in critical section 2 leaving critical section 3 in critical section 3 leaving critical section 4 in critical section 4 leaving critical section 0 in critical section 0 leaving critical section 1 in critical section 1 leaving critical section