Deadlock Prevention with tryLock
Table of Contents
- Introduction
- Understanding Deadlock in Multithreading
- The tryLock Mechanism in Java
- Code Explanation: Deadlock Prevention Example
- Conclusion
Introduction
Deadlock is one of the most notorious issues in multithreading programming, where two or more threads are blocked forever, each waiting for the other to release resources. In Java, we can encounter deadlock situations when dealing with shared resources between multiple threads. To mitigate this issue, Java provides a mechanism known as tryLock, which offers an elegant way to handle deadlock situations by attempting to acquire locks without getting stuck indefinitely.
This article focuses on preventing deadlocks using the tryLock method from the java.util.concurrent.locks.Lock interface, with a practical example implemented in Java.
When to Use tryLock?
The tryLock method is used when:
- You want to attempt locking resources but avoid blocking indefinitely.
- You need to implement time-bound waiting for resources.
- Handling high-concurrency situations where threads must avoid deadlocks.
| Feature | lock | tryLock |
|---|---|---|
| Blocking Behavior | Waits indefinitely to acquire lock | Attempts to acquire lock without waiting |
| Deadlock Prevention | Can cause deadlock | Helps avoid deadlock by limiting waiting time |
Understanding Deadlock in Multithreading
A deadlock occurs when two or more threads are waiting for each other to release resources they have locked, leading to a standstill. For example, if Thread 1 holds Lock A and waits for Lock B, while Thread 2 holds Lock B and waits for Lock A, neither thread can proceed, causing a deadlock.
Key Points of Deadlock:
- Circular wait: Threads are waiting in a circular chain.
- No preemption: Locks cannot be forcefully removed from a thread.
- Mutual exclusion: Resources are non-shareable.
- Hold and wait: Threads hold onto one resource and wait for another.
The tryLock Mechanism in Java
Java’s tryLock method provides a way to attempt acquiring a lock without waiting indefinitely. It can also be combined with a timeout, allowing the thread to try for a specified duration before giving up, thus preventing deadlock.
Syntax of tryLock:
|
1 |
boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException; |
- timeout: The maximum time to wait for the lock.
- unit: The time unit for the timeout.
Code Explanation: Deadlock Prevention Example
In this section, we’ll walk through a practical example of how tryLock prevents deadlock between two threads. The code attempts to acquire two locks (lock1 and lock2) in a non-blocking way using tryLock.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
package org.studyeasy; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Main { static Lock lock1 = new ReentrantLock(); static Lock lock2 = new ReentrantLock(); public static void main(String[] args) throws InterruptedException { Thread thread1 = new Thread(new Runnable() { @Override public void run() { boolean flagLock01 = false; boolean flagLock02 = false; while (true) { try { // Attempt to acquire lock1 and lock2 with a timeout flagLock01 = lock1.tryLock(10, TimeUnit.MILLISECONDS); flagLock02 = lock2.tryLock(10, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { e.printStackTrace(); } finally { // Release lock1 if acquired if (flagLock01) { System.out.println("Thread1, lock1"); lock1.unlock(); } // Release lock2 if acquired if (flagLock02) { System.out.println("Thread1, lock2"); lock2.unlock(); } // Exit the loop if both locks are acquired if (flagLock01 && flagLock02) { break; } } } } }); Thread thread2 = new Thread(new Runnable() { @Override public void run() { boolean flagLock01 = false; boolean flagLock02 = false; while (true) { try { // Attempt to acquire lock2 and lock1 with a timeout flagLock02 = lock2.tryLock(10, TimeUnit.MILLISECONDS); flagLock01 = lock1.tryLock(10, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { e.printStackTrace(); } finally { // Release lock2 if acquired if (flagLock02) { System.out.println("Thread2, lock2"); lock2.unlock(); } // Release lock1 if acquired if (flagLock01) { System.out.println("Thread2, lock1"); lock1.unlock(); } // Exit the loop if both locks are acquired if (flagLock01 && flagLock02) { break; } } } } }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println("Main Thread"); } } |
Step-by-Step Explanation:
- Locks Initialization: Two locks (lock1 and lock2) are created using ReentrantLock.
- Thread 1: The first thread tries to acquire both locks using tryLock. If successful, it releases the locks and breaks out of the loop.
- Thread 2: Similar to Thread 1, but it attempts to lock in reverse order to avoid circular wait conditions.
- Non-blocking Attempt: Each tryLock is given a 10-millisecond timeout to avoid indefinite waiting.
- Deadlock Prevention: Since both threads have a limited time to wait for locks, the system avoids deadlocks by releasing acquired locks and retrying.
Program Output:
|
1 2 3 4 5 |
Thread1, lock1 Thread1, lock2 Thread2, lock1 Thread2, lock2 Main Thread |
Conclusion
Deadlock prevention is crucial in multithreading, especially in environments with shared resources. Using tryLock is an effective strategy to ensure that threads do not get stuck waiting for each other indefinitely, thus avoiding deadlocks. The provided code demonstrates how two threads can acquire and release locks safely using timeouts. This approach ensures robust and responsive multithreaded programs.