How to avoid thread deadlock in Java

Thread deadlock is a common problem that can occur in multi-threaded Java programs. It occurs when two or more threads become stuck while waiting the release of a resource that is necessary for them to continue running. Here are some ways to avoid thread deadlock in Java:

Acquire locks in a consistent order: If multiple threads need locks on multiple objects, make sure they always acquire the locks in the same order. It avoids the scenario where one thread is holding a lock that another thread requires, while the first thread is holding a lock that it needs the second thread to release.
Release locks promptly: When a thread has finished using a shared resource, it should release the associated lock as soon as possible. It allows other threads to acquire the lock and continue their execution.
Use timeouts: When acquiring locks, you can specify a timeout period. If the lock cannot be acquired within the specified time, the thread can release the lock and try again later.
Use a single lock: If possible, use one lock to protect multiple resources. In order to avoid deadlock, it makes sure that only one thread can access the resources at once.
Use thread-safe classes: Instead of implementing your synchronization mechanism, use the thread-safe classes provided by the Java API. These classes have already been designed and tested to handle multi-threading correctly.
Avoid nested locks: Avoid acquiring locks on multiple objects in a nested fashion. It can lead to deadlocks, increasing the likelihood of two or more threads acquiring locks in a different order.

How to avoid thread deadlock in Java Programs

To avoid thread deadlocks in Java programs, you can follow these best practices:

1. Avoid nested synchronization blocks:

Several threads attempting to access the same resource while one is waiting for the other to relinquish it can lead to deadlocks. To avoid It, you should avoid nesting synchronized blocks.

Nested synchronization blocks occur when a thread acquires more than one lock in a nested manner. It leads to deadlocks because a thread waiting for a lock may end up waiting for a lock held by another thread.

Filename: DeadlockExample.java

// Java program to create a deadlock by creating two threads
// and each thread trying to acquire a lock of both locks
public class DeadlockExample {
static Object lock1 = new Object(); // Create object for lock1
static Object lock2 = new Object(); // Create object for lock2
public static void main(String[] args) {
// Create the first thread
Thread t1 = new Thread(new Runnable() {
public void run() {
synchronized (lock1) {
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for lock 2...");
synchronized (lock2) {
System.out.println("Thread 1: Holding lock 1 & 2...");
}
}
}
});
  // Create a second thread
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        synchronized (lock2) {
           System.out.println("Thread 2: Holding lock 2...");
           try {
              Thread.sleep(10);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 2: Waiting for lock 1...");
           synchronized (lock1) {
              System.out.println("Thread 2: Holding lock 1 & 2...");
           }
        }
     }
  });
  // Start both threads
  t1.start();
  t2.start();
}
}

Output:

Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 2: Waiting for lock 1...
Thread 1: Waiting for lock 2...

Explanation: In The example, both Thread 1 and Thread 2 are trying to acquire lock1 and lock2, but they are doing it in a different order. Deadlocks are situations when two threads are stuck waiting for the other to release the lock they require. To avoid It, it's recommended to avoid nested synchronization blocks whenever possible.

2. Acquire locks in a consistent order:

When multiple threads access shared resources, ensure each thread acquires locks consistently. It will prevent deadlocks from occurring.

It means that if multiple threads access shared resources, they should always acquire locks in the same order. It can help prevent deadlocks from occurring.

Filename: DeadlockAvoidanceExample.java

// A class to demonstrate deadlock avoidance in Java
public class DeadlockAvoidanceExample {
static Object lock1 = new Object(); // Create the first lock
static Object lock2 = new Object(); // Create the second lock
public static void main(String[] args) {
// Create the first thread
Thread t1 = new Thread(new Runnable() {
public void run() {
synchronized (lock1) { // Acquire lock1
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(10); // Pause for 10 milliseconds
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for lock 2...");
synchronized (lock2) { // Acquire lock2
System.out.println("Thread 1: Holding lock 1 & 2...");
}
}
}
});
  // Create the second thread
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        synchronized (lock1) { // Acquire lock1
           System.out.println("Thread 2: Holding lock 1...");
           try {
              Thread.sleep(10); // Pause for 10 milliseconds
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 2: Waiting for lock 2...");
           synchronized (lock2) { // Acquire lock2
              System.out.println("Thread 2: Holding lock 1 & 2...");
           }
        }
     }
  });
  
  t1.start(); // Start the first thread
  t2.start(); // Start the second thread
}
}

Output:

Thread 1: Holding lock 1...
Thread 1: Waiting for lock 2...
Thread 1: Holding lock 1 & 2...
Thread 2: Holding lock 1...
Thread 2: Waiting for lock 2...
Thread 2: Holding lock 1 & 2...

Explanation: In the It example, Thread 1 and Thread 2 acquire lock1 before lock2. They will never get stuck in a deadlock because they acquire the locks in the same order. It is an example of how acquiring locks in a consistent order can help prevent deadlocks from occurring in your Java programs.

3. Avoid waiting for a lock indefinitely:

A thread shouldn't keep waiting indefinitely for a lock. Instead, set a timeout for the lock so the thread can move on if the lock is not acquired promptly.

To avoid waiting for a lock indefinitely, you can use the tryLock() method of the Java.util.concurrent.locks.ReentrantLock class. The tryLock() method tries to acquire the lock but returns immediately if it cannot be acquired. It allows you to prevent your thread from waiting indefinitely for a lock.

Filename: DeadlockAvoidanceExample3.java

import java.util.concurrent.locks.ReentrantLock;
public class DeadlockAvoidanceExample3 {
static ReentrantLock lock1 = new ReentrantLock();
static ReentrantLock lock2 = new ReentrantLock();
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
public void run() {
boolean lock1Acquired = lock1.tryLock(); // Attempt to acquire lock1
if (!lock1Acquired) { // If unable to acquire lock1, return
System.out.println("Thread 1: Unable to acquire lock 1");
return;
}
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for lock 2...");
boolean lock2Acquired = lock2.tryLock(); // Attempt to acquire lock2
if (!lock2Acquired) { // If unable to acquire lock2, release lock1 and return
System.out.println("Thread 1: Unable to acquire lock 2");
lock1.unlock();
return;
}
System.out.println("Thread 1: Holding lock 1 & 2...");
lock2.unlock(); // Release lock2
lock1.unlock(); // Release lock1
}
});
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        boolean lock2Acquired = lock2.tryLock(); // Attempt to acquire lock2
        if (!lock2Acquired) { // If unable to acquire lock2, return
           System.out.println("Thread 2: Unable to acquire lock 2");
           return;
        }
        System.out.println("Thread 2: Holding lock 2...");
        try {
           Thread.sleep(10);
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
        System.out.println("Thread 2: Waiting for lock 1...");
        boolean lock1Acquired = lock1.tryLock(); // Attempt to acquire lock1
        if (!lock1Acquired) { // If unable to acquire lock1, release lock2 and return
           System.out.println("Thread 2: Unable to acquire lock 1");
           lock2.unlock();
           return;
        }
        System.out.println("Thread 2: Holding lock 1 & 2...");
        lock1.unlock(); // Release lock1
        lock2.unlock(); // Release lock2
     }
  });
  t1.start();
  t2.start();
}
}

Output:

Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 1: Waiting for lock 2...
Thread 1: Unable to acquire lock 2
Thread 2: Waiting for lock 1...
Thread 2: Holding lock 1 & 2...

Explanation: In the It example, we use the tryLock() method to try and acquire the lock. The method ends right away and the thread moves on to other tasks if the lock cannot be obtained. It helps to avoid waiting indefinitely for a lock and can help prevent deadlocks from occurring in your Java programs.

4. Use Reentrant Locks:

Reentrant locks can control access to resources in a deadlock-free manner. They allow a single thread to lock the resource multiple times, which can help avoid deadlocks.

Reentrant locks are a particular kind of lock that permit several locks to be made with the same thread. It means that a thread can acquire the lock, release it, and then acquire it again without causing a deadlock. It can be useful in avoiding deadlocks in complex, multi-threaded applications.

Filename: DeadlockAvoidanceExample4

// Importing ReentrantLock class from Java.util.concurrent.locks package
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockAvoidanceExample4 {
// Creating two ReentrantLock objects lock1 and lock2
static ReentrantLock lock1 = new ReentrantLock();
static ReentrantLock lock2 = new ReentrantLock();

public static void main(String[] args) {
// Creating and starting Thread t1
Thread t1 = new Thread(new Runnable() {
public void run() {
lock1.lock();
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for lock 2...");
lock2.lock();
System.out.println("Thread 1: Holding lock 1 & 2...");
lock2.unlock();
lock1.unlock();
}
});
  // Creating and starting Thread t2
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        lock2.lock();
        System.out.println("Thread 2: Holding lock 2...");
        try {
           Thread.sleep(10);
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
        System.out.println("Thread 2: Waiting for lock 1...");
        lock1.lock();
        System.out.println("Thread 2: Holding lock 1 & 2...");
        lock1.unlock();
        lock2.unlock();
     }
  });

  // Starting both threads
  t1.start();
  t2.start();
}
}}

Output:

Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 1: Waiting for lock 2...
Thread 2: Waiting for lock 1...

Explanation: In The example, we use Reentrant Locks to lock and unlock the resources. The lock can be acquired and released multiple times by the same thread, making it an ideal solution for complex, multi-threaded applications. It can help prevent deadlocks from occurring in your Java programs.

5. Use Executor Services:

Java provides a built-in executor service that can be used to manage thread execution. You can use Its service to manage the execution of tasks and ensure they are executed deadlock-free.

Executor Services are a way to manage multiple threads in a Java program. It allows you to execute a task in the background by submitting it to an executor. The executor then decides which thread should be used to execute the task. It helps to simplify the management of multiple threads, as well as to improve performance by reusing existing threads.

Filename: DeadlockAvoidanceExample5

// import necessary classes
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class DeadlockAvoidanceExample5 {
public static void main(String[] args) {
// create a thread pool with two threads
ExecutorService executorService = Executors.newFixedThreadPool(2);
  // define tasks to be executed by threads
  Runnable task1 = new Runnable() {
     public void run() {
        System.out.println("Thread 1: Running task 1...");
     }
  };
  Runnable task2 = new Runnable() {
     public void run() {
        System.out.println("Thread 2: Running task 2...");
     }
  };
  // submit tasks to the executor service for execution
  executorService.submit(task1);
  executorService.submit(task2);  
  // shutdown the executor service when all tasks are completed
  executorService.shutdown();
}
}

Output:

Thread 1: Running task 1...
Thread 2: Running task 2...

Explanation: In The example, we use an Executor Service to manage the execution of multiple tasks. The executor service uses a fixed pool of threads to execute the tasks, reducing the risk of deadlocks. It makes managing multiple threads easier and helps avoid deadlocks in your Java programs.

6. Monitor your code:

Regularly monitor your code for deadlocks. If a deadlock occurs, you should quickly identify and resolve it to avoid performance issues and delays in your application.

Monitoring your code is the process of monitoring the behaviour of your program and identifying potential deadlocks. It can be done by logging the state of your threads and using tools such as profilers to monitor the behaviour of your program.

Filename: DeadlockAvoidanceExample6

// Example code to demonstrate avoiding deadlock in Java using synchronized blocks and objects
public class DeadlockAvoidanceExample6 {
public static void main(String[] args) {
// Create two locks as objects
Object lock1 = new Object();
Object lock2 = new Object();
  // Create thread t1
  Thread t1 = new Thread(new Runnable() {
     public void run() {
        // Acquire lock1
        synchronized (lock1) {
           System.out.println("Thread 1: Holding lock 1...");
           try {
              Thread.sleep(10);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 1: Waiting for lock 2...");
           // Acquire lock2
           synchronized (lock2) {
              System.out.println("Thread 1: Holding lock 1 & 2...");
           }
       }
     }
  });
  // Create thread t2
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        // Acquire lock2
        synchronized (lock2) {
           System.out.println("Thread 2: Holding lock 2...");
           try {
              Thread.sleep(10);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 2: Waiting for lock 1...");
           // Acquire lock1
           synchronized (lock1) {
              System.out.println("Thread 2: Holding lock 1 & 2...");
           }
        }
     }
  });
  // Start both threads
  t1.start();
  t2.start();
}
}

Output:

Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 1: Waiting for lock 2...
Thread 2: Waiting for lock 1...

Explanation: In the example, we log the state of each thread to help identify any potential deadlocks. It can help you understand your program's behaviour and identify potential issues before they become critical. Additionally, you can use profilers to monitor the behaviour of your program and identify any performance issues that may be contributing to a deadlock. By monitoring your code and using tools to help identify potential deadlocks, you can ensure that your Java programs run smoothly and avoid deadlocks.

7. Avoid circular dependencies:

If multiple threads depend on each other, they can get stuck in a circular deadlock. To avoid It, you should avoid circular dependencies and make sure that the dependencies between threads are well-defined.

Circular dependencies can occur when two or more objects depend on each other in a way that creates a cycle. It can cause deadlocks as each object waits for the other to release a required resource. To avoid circular dependencies, it is important to design your program to prevent these dependencies from forming.

Filename: DeadlockAvoidanceExample7

// It program demonstrates a simple example of avoiding deadlock in Java using synchronized blocks and locking objects
// Two threads are created that synchronize on two different objects in the opposite order, thereby avoiding any potential deadlock
public class DeadlockAvoidanceExample7 {
public static void main(String[] args) {
// Create two objects to be used as locks
final Object lock1 = new Object();
final Object lock2 = new Object();
  // Create the first thread that synchronizes on lock1, then lock2
  Thread t1 = new Thread(new Runnable() {
     public void run() {
        synchronized (lock1) {
           System.out.println("Thread 1: Holding lock 1...");
           try {
              Thread.sleep(10);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 1: Waiting for lock 2...");
           synchronized (lock2) {
              System.out.println("Thread 1: Holding lock 1 & 2...");
           }
        }
     }
  });
  // Create a second thread that synchronizes on lock2, then lock1
  Thread t2 = new Thread(new Runnable() {
     public void run() {
        synchronized (lock2) {
           System.out.println("Thread 2: Holding lock 2...");
           try {
              Thread.sleep(10);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           System.out.println("Thread 2: Waiting for lock 1...");
           synchronized (lock1) {
              System.out.println("Thread 2: Holding lock 1 & 2...");
           }
        }
     }
  });
  // Start both threads
  t1.start();
  t2.start();
}
}

Output:

Thread 2: Holding lock 2...
Thread 1: Holding lock 1...
Thread 1: Waiting for lock 2...
Thread 2: Waiting for lock 1...

Explanation: In The example, we avoid circular dependencies by ensuring that each thread acquires locks in a different order. It prevents a cycle from forming, as each thread can obtain the required locks without waiting for the other to release them. By avoiding circular dependencies, you can ensure your Java programs run smoothly and avoid deadlocks.

Next TopicNumber of Squareful Arrays in Java

← prev next →