死锁

一. 什么是死锁

指的是两个或者两个以上的线程在执行的过程中由于竞争同步锁而产生的一种阻塞现象;如果没有外力的作用,他们将无法继续执行下去,这种情况称之为死锁,

通俗的说死锁产生的原因主要是由于线程的相互等待 , 导致程序无法进行下去

二. 代码阐述

这里我们写一段代码对死锁进行描述, 阐述其中的原理

1. LockA类 --> 设置线程

   public class LockA {
       public static LockA lockA = new LockA();
   }
   
   

2. LockB类 --> 设置线程

   public class LockB {
       public static LockB lockB = new LockB();
   }
   

3. DieLock类 --> 继承Runnable重写run方法

   public class DieLock implements Runnable{
       private boolean flag;
   
       public DieLock(boolean flag) {
           this.flag = flag;
       }
   
       @Override
       public void run() {
           if (flag){
               synchronized (LockA.lockA){
                   System.out.println("if...lockA");
                   synchronized (LockB.lockB){
                       System.out.println("if...lockB");
                   }
               }
           }else{
               synchronized (LockB.lockB){
                   System.out.println("else...lockB");
                   synchronized (LockA.lockA){
                       System.out.println("else...lockA");
                   }
               }
           }
       }
   }
   
   

4. Test01类 --> 实现类

   public class Test01 {
       public static void main(String[] args) {
           DieLock dieLock1 = new DieLock(true);
           DieLock dieLock2 = new DieLock(false);
   
           new Thread(dieLock1).start();
           new Thread(dieLock2).start();
       }
   }
   
   

场景描述

假设有两个线程 Thread1 和 Thread2，它们分别通过不同的构造函数参数初始化了 DieLock 对象：

• Thread1 初始化了 DieLock 对象，其中 flag 为 true。
• Thread2 初始化了 DieLock 对象，其中 flag 为 false。

执行流程

1. Thread1 执行

   • 首先获取 LockA.lockA 锁。
   • 然后尝试获取 LockB.lockB 锁。

2. Thread2 执行

   （几乎同时或稍后）：

   • 首先获取 LockB.lockB 锁（因为 flag 为 false）。
   • 然后尝试获取 LockA.lockA 锁。

死锁发生

• Thread1 已经持有 LockA.lockA 锁，并正在等待 LockB.lockB 锁。
• Thread2 已经持有 LockB.lockB 锁，并正在等待 LockA.lockA 锁。

由于两个线程都在等待对方释放它们需要的锁，它们都将无限期地等待下去，从而导致了死锁。

在这里由于synchronized 控制的是整个代码块 , 当程序执行完毕才会释放此时占有lockA锁

synchronized (LockA.lockA){
                System.out.println("if...lockA");
                synchronized (LockB.lockB){
                    System.out.println("if...lockB");
                }
            }

同理Thread2占有lockB锁 , 然而此时Thread1线程中LockA在等待LockB , Thread2线程中LockB 在等待LockA就会产生死锁

如果我们稍作修改 , 将Thread2 的第二层嵌套取消掉就会发现运行结果不一样了 , 死锁问题不会产生

此时Thread2在获得LockB之后运行完毕释放LockB , Thread1也能获取到LockB进而继续执行

public class DieLock implements Runnable{
    private boolean flag;

    public DieLock(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag){
            synchronized (LockA.lockA){
                System.out.println("if...lockA");
                synchronized (LockB.lockB){
                    System.out.println("if...lockB");
                }
            }
        }else{
            synchronized (LockB.lockB){
                System.out.println("else...lockB");
                
                }
            }
        }
    }
}