ECE 462 Object-Oriented Programming using C++ and Java. Scheduling and Critical Section

Transcription

1 ECE 462 Object-Oriented Programming g using C++ and Java Scheduling and Critical Section Yung-Hsiang Lu yunglu@purdue.edu d YHL Scheduling and Critical Section 1

2 Thread States born terminated ready running condition satisfied waiting sleeping YHL Scheduling and Critical Section 2

3 Scheduling YHL Scheduling and Critical Section 3

4 Scheduling (select the thread to use a processor) If there are more ready threads than the number of processors, the computer's scheduling algorithm decides which threads to run next. scheduling criteria i utilization throughput, turnaround time, and response time waiting time fairness priority deadline YHL Scheduling and Critical Section 4

5 Scheduling Algorithm First Come First Serve t1 ready t2 ready t3 ready t4 ready time YHL Scheduling and Critical Section 5

6 Round Robin + Time Slice t1 t1 t1 t2 t2 t2 t3 t3 t3 time YHL Scheduling and Critical Section 6

7 Scheduling + Interrupts interrupt interrupt t1 t1 time t2 t2 t3 t3 t3 ISR ISR YHL Scheduling and Critical Section 7

8 Thread Interleaving Class1::run() Class2::run() Class3::run() interrupt resume YHL Scheduling and Critical Section 8

9 Shared Data int d = 50; // global variable Class1::run() Class2::run() { { int x; int x; x = d; x = d; x = x + 10; x = x + 5; d = x; d = x; } } equivalent to d += 5; YHL Scheduling and Critical Section 9

10 Interleaving and Shared Data Class1::run() { int x; x = d; } x = x + 10; d = x; interrupted Class2::run() { int x; x = d; x=x+5; x d = x; } YHL Scheduling and Critical Section 10

11 Class1::run() { int x; x = d; Class2::run() { int x; x = d; } x = x + 5; d = x; interrupted } x = x + 10; d = x; YHL Scheduling and Critical Section 11

12 Conditions for Wrong Results multiple threads shared data and at least one thread modifies the data operations with multiple steps interrupts may occur between the steps another thread may execute while one thread is suspended YHL Scheduling and Critical Section 12

13 Atomic Operation An operation is "atomic" if it must execute to completion once the operation starts. In Java, only 32-bit (or smaller) assignments are atomic. Even x += y; is not atomic. The code (some statements in run) to modify a shared variable or object has to be atomic. YHL Scheduling and Critical Section 13

14 Mutual Exclusion (Mutex) Used when a shared (by multiple threads) variable / object may be modified and can lead to inconsistency. If the variable is read-only, mutex is unnecessary. If a variable / object is read by a thread and written by another thread, both threads must use mutex to protect the variable / object. Mutex serializes a multi-thread program. The code that is protected by Mutex is called critical section. Only one is allowed in the room. If the room is locked by someone, no one else cannot enter the room, until the person in the room leaves. YHL Scheduling and Critical Section 14

15 ECE 462 Object-Oriented Programming g using C++ and Java Synchronization Yung-Hsiang Lu yunglu@purdue.edu d YHL Synchronization 1

16 Threads Sharing Objects YHL Synchronization 2

17 Java object shared by four threads YHL Synchronization 3

18 YHL Synchronization 4

19 YHL Synchronization 5

20 YHL Synchronization 6

21 RepeatedSwaps RepeatedSwaps d (shared) RepeatedSwaps RepeatedSwaps YHL Synchronization 7

22 YHL Synchronization 8

23 C++ YHL Synchronization 9

24 YHL Synchronization 10

25 YHL Synchronization 11

26 YHL Synchronization 12

27 Synchronization YHL Synchronization 13

28 YHL Synchronization 14

29 synchronized Methods All synchronized methods of the same object share the same lock only one thread can acquire the lock Can one synchronized method calls another synchronized method? Yes Can two threads calls the synchronized methods of two objects simultaneously? Yes Can one thread calls one object s synchronized method that calls another object s synchronized method? Yes Can a constructor be synchronized? No YHL Synchronization 15

30 YHL Synchronization 16

31 YHL Synchronization 17

32 Conditional Wait YHL Synchronization 18

33 YHL Synchronization 19

34 YHL Synchronization 20

35 YHL Synchronization 21

36 shared object YHL Synchronization 22

37 YHL Synchronization 23

38 YHL Synchronization 24

39 YHL Synchronization 25

40 YHL Synchronization 26

41 YHL Synchronization 27