面试官:死锁是如何产生的?怎么解决?

开发 前端
死锁(Dead Lock)指的是两个或两个以上的运算单元(进程、线程或协程),都在等待对方释放资源,但没有一方提前释放资源,从而造成了一种阻塞的现象就称为死锁。

死锁(Dead Lock)指的是两个或两个以上的运算单元(进程、线程或协程),都在等待对方释放资源,但没有一方提起释放资源,从而造成了一种阻塞的现象就称为死锁。

比如线程 1 拥有了锁 A 的情况下试图获取锁 B,而线程 2 又在拥有了锁 B 的情况下试图获取锁 A,这样双方就进入相互阻塞等待的情况,如下图所示:

图片

死锁的代码实现如下:

import java.util.concurrent.TimeUnit;

public class DeadLockTest {
public static void main(String[] args) {
Object lockA = new Object();
Object lockB = new Object();
// 创建线程 1
Thread t1 = new Thread(() -> {
// 1.占有锁 A
synchronized (lockA) {
System.out.println("线程1:获得锁A。");
// 休眠 1s(让线程 2 有时间先占有锁 B)
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 2.获取线程 2 的锁 B
synchronized (lockB) {
System.out.println("线程1:获得锁B。");
}
}
});
t1.start();
// 创建线程 2
Thread t2 = new Thread(() -> {
// 1.占有锁 B
synchronized (lockB) {
System.out.println("线程2:获得锁B。");
// 休眠 1s(保证线程 1 能有充足的时间得到锁 A)
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 2.获取线程 1 的锁 A
synchronized (lockA) {
System.out.println("线程2:获得锁A。");
}
}
});
t2.start();
}
}

以上程序的执行结果如下图所示:

图片

从上述结果可以看出,线程 1 和线程 2 都在等待对方释放锁,这样就造成了死锁问题。

死锁产生原因

死锁的产生需要满足以下 4 个条件:

  1. 互斥条件:指运算单元(进程、线程或协程)对所分配到的资源具有排它性,也就是说在一段时间内某个锁资源只能被一个运算单元所占用。
  2. 请求和保持条件:指运算单元已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它运算单元占有,此时请求运算单元阻塞,但又对自己已获得的其它资源保持不放。
  3. 不可剥夺条件:指运算单元已获得的资源,在未使用完之前,不能被剥夺。
  4. 环路等待条件:指在发生死锁时,必然存在运算单元和资源的环形链,即运算单元正在等待另一个运算单元占用的资源,而对方又在等待自己占用的资源,从而造成环路等待的情况。

只有以上 4 个条件同时满足,才会造成死锁。

解决死锁

死锁产生要满足以上 4 个必要条件,那么我们只需要改变其中的 1 个或多个条件就可以解决死锁的问题了,比如我们可以通过修改获取锁的顺序来改变环路等待条件。

在未修改获取锁的顺序前,程序的执行流程是这样的:

图片

其中 ① 表示先执行,② 表示后执行。而改变锁的获取顺序之后的执行流程是这样的:

图片

此时线程 1 和线程 2 获取锁的顺序是一致的,都是先获取锁 A,再获取锁 B,此时它们的执行流程如下:

  1. 线程 1 先获取到锁 A;
  2. 线程 1 获取到锁 B;
  3. 线程 1 释放了锁 B;
  4. 线程 1 释放了锁 A;
  5. 线程 2 获取到了锁 A;
  6. 线程 2 获取到了锁 B;
  7. 线程 2 释放了锁 B;
  8. 线程 2 释放了锁 A。

对应的实现代码如下:

import java.util.concurrent.TimeUnit;

class DeadLockTest {
public static void main(String[] args) {
Object lockA = new Object();
Object lockB = new Object();
// 创建线程 1
Thread t1 = new Thread(() -> {
// 1.获取锁 A
synchronized (lockA) {
System.out.println("线程1:获得锁A。");
// 休眠 1s
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 2.获取锁 B
synchronized (lockB) {
System.out.println("线程1:获得锁B。");
System.out.println("线程1:释放锁B。");
}
System.out.println("线程1:释放锁A。");
}
});
t1.start();
// 创建线程 2
Thread t2 = new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 1.获取锁 A
synchronized (lockA) {
System.out.println("线程2:获得锁A。");
// 2.获取锁
synchronized (lockB) {
System.out.println("线程2:获得锁B。");
System.out.println("线程2:释放锁B。");
}
System.out.println("线程2:释放锁A。");
}
});
t2.start();
}
}

以上程序的执行结果如下图所示:

图片

总结

死锁(Dead Lock)指的是两个或两个以上的运算单元(进程、线程或协程),都在等待对方释放资源,但没有一方提前释放资源,从而造成了一种阻塞的现象就称为死锁。产生死锁需要同时满足 4 个条件:互斥条件、请求和保持条件、不可剥夺条件、环路等待条件,因此我们只需要破坏其中 1 个或多个条件就可以解决死锁的问题了。

责任编辑:武晓燕 来源: Java面试真题解析
相关推荐

2023-02-16 08:10:40

死锁线程

2024-02-04 10:08:34

2015-08-13 10:29:12

面试面试官

2020-09-14 06:57:30

缓存穿透雪崩

2021-04-12 21:34:29

Redis故障数据

2023-12-19 09:24:22

LinuxBIOSUEFI

2021-09-27 07:11:18

MySQLACID特性

2021-01-18 05:13:04

TomcatHttp

2010-08-12 16:28:35

面试官

2021-09-07 10:44:33

Java 注解开发

2021-02-19 10:02:57

HTTPSJava安全

2017-03-16 15:27:10

面试官测试技术

2023-11-27 08:32:02

元素HashMap

2023-11-06 17:39:35

JavaArrayList线程

2022-09-29 07:30:57

数据库索引字段

2020-12-08 09:25:41

死锁MySQL数据库

2024-02-22 15:36:23

Java内存模型线程

2021-12-08 06:53:29

面试动态代理

2022-05-11 07:41:55

死锁运算线程

2021-07-06 07:08:18

管控数据数仓
点赞
收藏

51CTO技术栈公众号