赶紧收藏！2024 年最常见 100道 Java 基础面试题（二十五）

上一篇地址：赶紧收藏！2024 年最常见 100道 Java 基础面试题（二十四）-CSDN博客

四十九、什么是死锁？

死锁是计算机科学中一个重要的概念，尤其在并发编程和多线程环境中。在Java中，死锁同样是一个需要关注的问题。

死锁的定义：死锁是指在多线程环境中，两个或多个线程在执行过程中，因争夺资源而造成的一种僵局。当线程A持有资源B，等待资源C；线程B持有资源C，等待资源B；由于两个线程都在等待对方持有的资源，如果没有外力干涉，它们将永远无法向前推进，这就是死锁。

死锁的必要条件：死锁存在以下四个必要条件，这四个条件必须同时满足，缺一不可：

互斥：每个资源要么已经被一个线程占有，要么处于空闲状态，资源不能被多个线程共享。
占有和等待：至少有一个线程至少占有一个资源，并且等待获取其他线程占有的资源。
不可抢占：已经占有资源的线程不能被其他线程强行抢占资源，只能由线程自愿释放。
循环等待：存在一组等待资源的线程{T1, T2, ..., Tn}，其中线程T1等待T2占有的资源，T2等待T3占有的资源，...，Tn等待T1占有的资源，形成一个循环。

死锁的影响：死锁会导致程序无法继续执行，线程处于阻塞状态，浪费系统资源，严重时甚至会导致整个系统服务不可用。

死锁的避免和解决：

避免循环等待：通过合理安排资源的分配顺序，避免形成循环等待的条件。
加锁顺序：所有线程按照相同的顺序加锁。
超时机制：给线程的锁等待设置超时时间，超时后尝试其他路径。
死锁检测：操作系统或Java虚拟机可以检测到死锁，并进行相应的处理。
资源分配图：使用资源分配图分析死锁，找出并中断死锁链上的某个进程。

示例代码：

class DeadlockExample {static Object lock1 = new Object();static Object lock2 = new Object();public static void main(String[] args) {new Thread(() -> {synchronized (lock1) {System.out.println("Thread 1: Locked lock1");try { Thread.sleep(100); } catch (InterruptedException e) {}synchronized (lock2) {System.out.println("Thread 1: Locked lock2");}}}).start();new Thread(() -> {synchronized (lock2) {System.out.println("Thread 2: Locked lock2");try { Thread.sleep(100); } catch (InterruptedException e) {}synchronized (lock1) {System.out.println("Thread 2: Locked lock1");}}}).start();}
}

在这个示例中，两个线程分别尝试按不同的顺序锁定两个资源，导致死锁。

总结：

死锁是并发编程中的一个常见问题，它发生在多个线程互相等待对方所占有的资源。
死锁的避免和解决需要合理的资源分配策略和锁管理。
了解死锁的必要条件有助于在设计和审查并发程序时预防死锁的发生。

五十、怎么防止死锁？

防止死锁是多线程编程中的一个重要议题，因为死锁会导致程序无法继续执行，造成资源浪费甚至系统服务不可用。以下是一些防止死锁的常见策略：

加锁顺序：确保所有线程都按照相同的顺序获取锁。这样可以避免形成循环等待的条件，从而防止死锁。

// 确保线程都按照相同的顺序锁定资源
synchronized(lock1) {synchronized(lock2) {// 临界区代码}
}

加锁超时：在尝试获取锁时使用超时机制，如果在指定的时间内无法获取所有需要的锁，则放弃并释放已持有的锁，之后可以重试。

public boolean tryLockWithTimeout(Lock lock, long timeout, TimeUnit unit) {try {return lock.tryLock(timeout, unit);} catch (InterruptedException e) {// 处理中断异常return false;}
}

死锁检测：实现一个算法来检测程序中是否存在死锁，并在检测到死锁时进行相应的处理，如中断线程或回滚事务。
尽可能使用java.util.concurrent包：这个包提供了一些线程安全的集合和原子变量，它们比使用同步代码块更不容易引发死锁。
减少锁的使用：尽可能避免使用锁，例如通过将数据设计为不可变，或者使用ThreadLocal存储线程特定的数据。
锁粗化：将多个连续的锁操作合并成一个锁，减少锁的请求次数，从而降低死锁的可能性。
使用ReentrantLock： ReentrantLock提供了比synchronized更灵活的锁操作，如尝试非阻塞的获取锁。
避免在循环中获取锁：在循环中获取多个锁可能导致死锁，因为其他线程可能以不同的顺序请求这些锁。
使用java.util.concurrent中的原子变量：原子变量如AtomicInteger不需要使用锁即可实现线程安全的计数器功能。
设计良好的资源分配策略：在分配资源时，避免资源的循环分配，确保资源分配策略不会导致循环等待。
使用死锁检测工具：使用操作系统或JVM提供的工具来检测死锁，如JVM的jconsole和jstack工具。
避免不必要的锁定：如果一个操作涉及多个步骤，并且可以不使用锁来保证数据一致性，则尽量避免使用锁。

示例代码：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class DeadlockPreventionExample {private static final Lock lock1 = new ReentrantLock();private static final Lock lock2 = new ReentrantLock();public static void methodOne() {lock1.lock();try {// 执行需要lock1的操作lock2.lock();try {// 执行需要同时持有lock1和lock2的操作} finally {lock2.unlock();}} finally {lock1.unlock();}}public static void methodTwo() {// 尝试获取lock2，如果获取失败，则释放所有已持有的锁if (lock2.tryLock()) {try {// 尝试获取lock1if (lock1.tryLock()) {try {// 执行需要同时持有lock1和lock2的操作} finally {lock1.unlock();}}} finally {lock2.unlock();}}}
}

总结：