SSC - Concurrency and Multi-threading Advanced topics about liveness

Transcription

1 SSC - Concurrency and Multi-threading Advanced topics about liveness Shan He School for Computational Science University of Birmingham Module : SSC

2 Outline Outline of Topics Review what we learned Detect deadlock automatically Starvation and Livelock

3 Deadlock Liveness means the ability of an application to execute in a timely manner Liveness problems include deadlock, starvation and livelock Deadlock: a situation where threads are blocked forever, waiting for each other: Can be two threads waiting for another to release a lock Can be more than two threads are waiting for resources in a circular chain A Java example

4 Deadlocks: how to deal with them Four Strategies: Ostrich algorithm: put your head in the sand approach. Ignore the problem if deadlocks are believed to be very rare, and if the cost of detection or prevention is high. Deadlock detection and recovery - fix the problem afterwards Dynamic avoidance: careful lock management/allocation Prevention: make one of the four conditions invalid

5 How to deal with deadlock? Prevention: make one or more conditions invalid No mutually exclusive access to resource: Nonblocking Synchronization (next week) Threads should not hold resources while waiting Allow resources to be taken away from threads No circular wait: lock ordering design, see blow Dynamic avoidance: Lock ordering: make sure all locks are always taken in the same order by any thread Lock timeout: put a timeout on lock attempts Deadlock detection: manually or algorithmically use a data structure, i.e., graph to detect deadlock

6 How to avoid deadlock: Lock ordering In the previous Java deadlock example, deadlock occurs when two threads need the same locks but obtain them in different order: Thread 1: locks Resource 1 and then Resource 2 Thread 2: locks Resource 2 and then Resource 1 We can use lock ordering technique to make sure all locks are taken in the same order by the two threads: Thread 1: locks Resource 1 and then Resource 2 Thread 2: locks Resource 1 and then Resource 2 A simple yet effective deadlock prevention technique Restricted: you must know about all locks requested by all threads before taking any of the locks

7 How to avoid deadlock: Lock timeout Put a timeout on lock attempts: a thread will try to obtain a lock with a maximum of time period What happen to the thread if timeout: interrupted free all locks it has taken wait for a random amount of time retry obtaining the locks Random amount of time: give other threads trying to take the same locks a chance to take all locks let the application continue running without deadlock. Complicated and cannot be used in Synchronized statements/methods: we need to use Reentrant Synchronization

8 How to avoid deadlock: Deadlock detection Can be done manually or algorithmically Use Resource-Allocation Graph Searches for a cycle in the graph. If there is a cycle, there MIGHT exist a deadlock Resource vertex Resource A Assignment edge Thread vertex Thread 1 Thread 2 Resource B Request edge

9 Deadlock detection: example Let s see an Java example: two threads T1 and T2, and 2 mutually exclusive accessible variables, a and b Thread 1 Thread 2 a += 2; b += 2; b += 5; a += 5; a += b; a += b; a += 13; b += 13; Question: Will these two threads cause deadlock?

10 Deadlock detection: example Answer: Let s take a look at what will happen: Thread 1 Thread 2 lock (lock a); lock (lock b); a += 2; b += 2; lock (lock b); lock (lock a); b += 5; a += 5; a += b; a += b; unlock (lock b); unlock (lock a); a += 13; b += 13; unlock (lock a); unlock (lock b);

11 Detect deadlock automatically Deadlock detection: automatic techniques Model checking: Check a model of a system, exhaustively and automatically to see whether this model meets a given specification, e.g., the absence of deadlocks After finding deadlock: we can use the following methods to correct the deadlock: Termination: One or more threads involved in the deadlock may be aborted. Resource Preemption: Resources allocated to various threads may be successively preempted and allocated to other threads to break the deadlock.

12 Detect deadlock automatically Debugging deadlock in Eclipse Step 1: Launch a debug session Step 2: Wait for deadlock happens Step 3: Switch to Debug perspective Step 4: Pause the process by clicking Suspend Step 5: Click View Menu Java Show monitors Step 6: Threads that are in deadlock will be indicated in red.

13 Detect deadlock automatically ThreadMXBean interface The management interface for the thread system of the Java virtual machine Can be used for finding deadlocks in the running application: finddeadlockedthreads() : Finds cycles of threads that are in deadlock waiting to acquire object monitors or ownable synchronizers. Designed for troubleshooting use, but not for synchronization control. An expensive operation. Java example

14 Detect deadlock automatically Question: deadlock between two polite people Read Oracle Deadlock Tutorial Draw a Resource-Allocation Graph

15 Starvation and Livelock Starvation Starvation: also called resource starvation. A situation that a thread is unable to gain regular access to shared resources, e.g., CPU time and is unable to make progress What caused starvation? Threads with high priority take all resources such as CPU time from threads with lower priority. Lock Starvation cause by synchronized blocks: a thread might be forever waiting to enter a synchronized block because it is unable to obtain the lock since other threads constantly obtained the lock before it - not deadlock since only one thread involved! These situations are usually caused by scheduling algorithms

16 Starvation and Livelock Livelock Similar to a deadlock, except that the states of the threads involved in the livelock constantly change with regard to one another, none progressing. A special case of starvation: starvation occurs to one thread without another thread being cyclically blocked One real-world example: two polite people meet in a narrow corridor, and each tries to move aside to let the other pass, but since both move the same way at the same time, they end up swaying from side to side without making any progress. A Java example

17 Starvation and Livelock How to avoid starvation and livelock? Basic idea: to ensure fairness between threads Switch priorities so that every thread has a chance to have high priority: Use FIFO order among competing requests Raise priority if a thread has been waiting too long In Java, we might need more control over synchronization (lock) to design a fair lock to avoid starvation and livelock