How To Handle Deadlock In Java? Examples

Deadlock in Java is a part of multithreading. Deadlock can occur in a situation when a thread is waiting for an object lock, that is acquired by another thread and second thread is waiting for an object lock that is acquired by first thread. Since, both threads are waiting for each other to release the lock, the condition is called deadlock.

Example of Deadlock in Java

More Complicated Deadlocks

A deadlock may also include more than two threads. The reason is that it can be difficult to detect a deadlock. Here is an example in which four threads have deadlocked:

Thread 1 waits for thread 2, thread 2 waits for thread 3, thread 3 waits for thread 4, and thread 4 waits for thread 1.

How to avoid deadlock?

A solution for a problem is found at its roots. In deadlock it is the pattern of accessing the resources A and B, is the main issue. To solve the issue we will have to simply re-order the statements where the code is accessing shared resources.

In the above code, class DeadlockSolved solves the deadlock kind of situation. It will help in avoiding deadlocks, and if encountered, in resolving them.

How to Avoid Deadlock in Java?

Deadlocks cannot be completely resolved. But we can avoid them by following basic rules mentioned below:

As configurations are shared resources and when accessing via Threads, there is always chance of writing incorrect code which can cause in deadlock situation.

1. Deadlock

In Java, a deadlock is a situation where minimum two threads are holding the lock on some different resource, and both are waiting for other’s resource to complete its task. And, none is able to leave the lock on the resource it is holding.

ResolveDeadLockTest.java
`package` `thread;` `public` `class` `ResolveDeadLockTest {` `public` `static` `void` `main(String[] args) {` `ResolveDeadLockTest test =` `new` `ResolveDeadLockTest();` `final` `A a = test.new` `A();` `final` `B b = test.new` `B();` `// Thread-1` `Runnable block1 =` `new` `Runnable() {` `public` `void` `run() {` `synchronized` `(a) {` `try` `{` `// Adding delay so that both threads can start trying to` `// lock resources` `Thread.sleep(100);` `}` `catch` `(InterruptedException e) {` `e.printStackTrace();` `}` `// Thread-1 have A but need B also` `synchronized` `(b) {` `System.out.println("In block 1");` `}` `}` `}` `};` `// Thread-2` `Runnable block2 =` `new` `Runnable() {` `public` `void` `run() {` `synchronized` `(b) {` `// Thread-2 have B but need A also` `synchronized` `(a) {` `System.out.println("In block 2");` `}` `}` `}` `};` `new` `Thread(block1).start();` `new` `Thread(block2).start();` `}` `// Resource A` `private` `class` `A {` `private` `int` `i =` `10;` `public` `int` `getI() {` `return` `i;` `}` `public` `void` `setI(int` `i) {` `this.i = i;` `}` `}` `// Resource B` `private` `class` `B {` `private` `int` `i =` `20;` `public` `int` `getI() {` `return` `i;` `}` `public` `void` `setI(int` `i) {` `this.i = i;` `}` `}` `}`

Running above code will result in a deadlock for very obvious reasons (explained above). Now we have to solve this issue.

Grab the opportunity to learn Python with Entri! Click Here

2. How to avoid deadlock

I believe, the solution to any problem lies in identifying the root of the problem. In our case, it is the pattern of accessing the resources A and B, is main issue. So, to solve it, we will simply re-order the statements where the code is accessing shared resources.

ResolveDeadLockTest.java

     // Thread-1
Runnable block1 = new Runnable() {
  public void run() {
    synchronized (b) {
      try {
        // Adding delay so that both threads can start trying to
        // lock resources
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      // Thread-1 have A but need B also
      synchronized (a) {
        System.out.println("In block 1");
      }
    }
  }
};
// Thread-2
Runnable block2 = new Runnable() {
  public void run() {
    synchronized (b) {
      // Thread-2 have B but need A also
      synchronized (a) {
        System.out.println("In block 2");
      }
    }
  }
};