Solutions to deadlocks encountered in java development

This article mainly introduces the detailed explanation and simple examples of java multi-threaded deadlock. Friends who need it can refer to it

Deadlock is a situation where multiple threads are blocked at the same time. One or all of them are waiting for a resource to be released. Because the thread is blocked indefinitely, the program cannot terminate gracefully.

java Four necessary conditions for deadlock:

1>Mutually exclusive use, that is, when a resource is used (occupied) by one thread, other The thread cannot be used

2> It is not preemptible. The resource requester cannot forcibly seize the resource from the resource owner, and the resource can only be actively released by the resource owner.

3> Request and maintain, that is, when the resource requester requests other resources while maintaining comrades in the original resources.

4>LoopWaiting, that is, there is a waitingqueue: P1 occupies the resources of P2, P2 occupies the resources of P3, and P3 occupies the resources of P1. This creates a waiting loop.

When the above four conditions are true, a deadlock is formed. Of course, in the case of deadlock, if any of the above conditions are broken, the deadlock will disappear. Let's use java code to simulate the occurrence of deadlock.

The methods to solve the deadlock problem are: one is to use synchronized, and the other is to use Lock explicit lock implementation.

And if the lock is used improperly and multiple objects need to be locked at the same time, a deadlock situation will occur, as follows:

/*
 author by w3cschool.cc
 LockTest.java
 */
import java.util.Date;
public class LockTest {
  public static String obj1 = "obj1";
  public static String obj2 = "obj2";
  public static void main(String[] args) {
   LockA la = new LockA();
   new Thread(la).start();
   LockB lb = new LockB();
   new Thread(lb).start();
  }
}
class LockA implements Runnable{
  public void run() {
   try {
     System.out.println(new Date().toString() + " LockA 开始执行");
     while(true){
      synchronized (LockTest.obj1) {
        System.out.println(new Date().toString() + " LockA 锁住 obj1");
        Thread.sleep(3000); // 此处等待是给B能锁住机会
        synchronized (LockTest.obj2) {
         System.out.println(new Date().toString() + " LockA 锁住 obj2");
         Thread.sleep(60 * 1000); // 为测试，占用了就不放
        }
      }
     }
   } catch (Exception e) {
     e.printStackTrace();
   }
  }
}
class LockB implements Runnable{
  public void run() {
   try {
     System.out.println(new Date().toString() + " LockB 开始执行");
     while(true){
      synchronized (LockTest.obj2) {
        System.out.println(new Date().toString() + " LockB 锁住 obj2");
        Thread.sleep(3000); // 此处等待是给A能锁住机会
        synchronized (LockTest.obj1) {
         System.out.println(new Date().toString() + " LockB 锁住 obj1");
         Thread.sleep(60 * 1000); // 为测试，占用了就不放
        }
      }
     }
   } catch (Exception e) {
     e.printStackTrace();
   }
  }
}

The output result of running the above code is:

Tue May 05 10:51:06 CST 2015 LockB 开始执行
Tue May 05 10:51:06 CST 2015 LockA 开始执行
Tue May 05 10:51:06 CST 2015 LockB 锁住 obj2
Tue May 05 10:51:06 CST 2015 LockA 锁住 obj1

At this time, a deadlock occurs.

In order to solve this problem, we do not use explicit de-locking, we use semaphore control.

The semaphore can control how many threads the resource can be accessed. Here we specify that it can only be accessed by one thread, which is similar to locking. The semaphore can specify the timeout period for acquisition, and we can do additional processing based on this timeout period.

In the case of failure to obtain successfully, you can generally try again, or specify the number of attempts, or you can exit immediately.

Let’s take a look at the following code:

/*
 author by w3cschool.cc
 UnLockTest.java
 */
import java.util.Date;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class UnLockTest {
  public static String obj1 = "obj1";
  public static final Semaphore a1 = new Semaphore(1);
  public static String obj2 = "obj2";
  public static final Semaphore a2 = new Semaphore(1);
  public static void main(String[] args) {
   LockAa la = new LockAa();
   new Thread(la).start();
   LockBb lb = new LockBb();
   new Thread(lb).start();
  }
}
class LockAa implements Runnable {
  public void run() {
   try {
     System.out.println(new Date().toString() + " LockA 开始执行");
     while (true) {
      if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
        System.out.println(new Date().toString() + " LockA 锁住 obj1");
        if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
         System.out.println(new Date().toString() + " LockA 锁住 obj2");
         Thread.sleep(60 * 1000); // do something
        }else{
         System.out.println(new Date().toString() + "LockA 锁 obj2 失败");
        }
      }else{
        System.out.println(new Date().toString() + "LockA 锁 obj1 失败");
      }
      UnLockTest.a1.release(); // 释放
      UnLockTest.a2.release();
      Thread.sleep(1000); // 马上进行尝试，现实情况下do something是不确定的
     }
   } catch (Exception e) {
     e.printStackTrace();
   }
  }
}
class LockBb implements Runnable {
  public void run() {
   try {
     System.out.println(new Date().toString() + " LockB 开始执行");
     while (true) {
      if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
        System.out.println(new Date().toString() + " LockB 锁住 obj2");
        if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
         System.out.println(new Date().toString() + " LockB 锁住 obj1");
         Thread.sleep(60 * 1000); // do something
        }else{
         System.out.println(new Date().toString() + "LockB 锁 obj1 失败");
        }
      }else{
        System.out.println(new Date().toString() + "LockB 锁 obj2 失败");
      }
      UnLockTest.a1.release(); // 释放
      UnLockTest.a2.release();
      Thread.sleep(10 * 1000); // 这里只是为了演示，所以tryAcquire只用1秒，而且B要给A让出能执行的时间，否则两个永远是死锁
     }
   } catch (Exception e) {
     e.printStackTrace();
   }
  }
}

The output structure of the above example code is:

Tue May 05 10:59:13 CST 2015 LockA 开始执行
Tue May 05 10:59:13 CST 2015 LockB 开始执行
Tue May 05 10:59:13 CST 2015 LockB 锁住 obj2
Tue May 05 10:59:13 CST 2015 LockA 锁住 obj1
Tue May 05 10:59:14 CST 2015LockB 锁 obj1 失败
Tue May 05 10:59:14 CST 2015LockA 锁 obj2 失败
Tue May 05 10:59:15 CST 2015 LockA 锁住 obj1
Tue May 05 10:59:15 CST 2015 LockA 锁住 obj2

[Related Recommended】

1. Java Video Tutorial

2. JAVA Tutorial Manual

3. Geek Academy Java Video Tutorial

The above is the detailed content of Solutions to deadlocks encountered in java development. For more information, please follow other related articles on the PHP Chinese website!