面试题：设计一个复杂场景下Java死锁预防与检测的方案

代码层面的锁策略优化

避免嵌套锁：尽量避免一个线程同时获取多个锁。如果必须获取多个锁，确保所有线程以相同的顺序获取锁。例如：

class Resource {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            // 业务逻辑
            synchronized (lock2) {
                // 更多业务逻辑
            }
        }
    }

    public void method2() {
        synchronized (lock1) {
            // 业务逻辑
            synchronized (lock2) {
                // 更多业务逻辑
            }
        }
    }
}

使用定时锁：使用 Lock 接口的 tryLock(long time, TimeUnit unit) 方法，设置获取锁的超时时间。如果在规定时间内没有获取到锁，则放弃尝试，避免死锁。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

class ResourceWithTimedLock {
    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();

    public void method() {
        boolean gotLock1 = false;
        boolean gotLock2 = false;
        try {
            gotLock1 = lock1.tryLock(100, TimeUnit.MILLISECONDS);
            if (gotLock1) {
                gotLock2 = lock2.tryLock(100, TimeUnit.MILLISECONDS);
                if (gotLock2) {
                    // 业务逻辑
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            if (gotLock2) lock2.unlock();
            if (gotLock1) lock1.unlock();
        }
    }
}

减少锁的粒度：将大的锁范围细化为多个小的锁，只对需要保护的资源加锁。例如，对于一个包含多个元素的集合，为每个元素分配单独的锁。

import java.util.HashMap;
import java.util.Map;

class FineGrainedLocking {
    private final Map<Integer, Object> locks = new HashMap<>();

    public FineGrainedLocking() {
        for (int i = 0; i < 100; i++) {
            locks.put(i, new Object());
        }
    }

    public void accessElement(int index) {
        Object lock = locks.get(index);
        synchronized (lock) {
            // 访问元素的业务逻辑
        }
    }
}

运行时的死锁检测机制

利用JVM自带工具
- jstack：在命令行中使用 jstack <pid> 命令，pid 是Java进程的ID。它会打印出Java进程中所有线程的堆栈信息。通过分析堆栈信息，可以找出死锁的线程。例如，如果两个线程互相等待对方释放锁，在堆栈信息中会看到相应的等待状态。
- VisualVM：这是一个可视化的工具，可以连接到正在运行的Java进程。在“线程”标签页中，可以实时查看线程的状态，并且如果发生死锁，会有相应的提示并展示死锁相关线程的信息。
自定义工具
- 基于线程监控：创建一个后台线程，定期检查所有线程的状态和持有锁的情况。可以通过 ThreadMXBean 获取线程的锁信息。例如：

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

public class DeadlockDetector {
    private static final ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();

    public static void startDeadlockDetection() {
        Thread detectorThread = new Thread(() -> {
            while (true) {
                long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
                if (deadlockedThreads != null) {
                    for (long threadId : deadlockedThreads) {
                        ThreadInfo threadInfo = threadMXBean.getThreadInfo(threadId);
                        System.out.println("Detected deadlock in thread: " + threadInfo.getThreadName());
                    }
                }
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        detectorThread.setDaemon(true);
        detectorThread.start();
    }
}

- **基于锁监控**：维护一个锁的使用记录，记录每个锁被哪个线程获取和释放的时间。通过分析这些记录，检测是否存在死锁模式。例如，可以使用 `AspectJ` 或自定义代理来在锁获取和释放方法前后插入记录逻辑。

方案在高并发、多线程且资源竞争激烈场景下的可行性与扩展性

可行性
- 锁策略优化：避免嵌套锁、使用定时锁和减少锁粒度这些策略在高并发场景下是可行的。避免嵌套锁和以相同顺序获取锁能从根本上杜绝死锁产生的一种常见原因。定时锁机制可以让线程在无法获取锁时及时放弃，避免无限等待。减少锁粒度虽然会增加锁的管理开销，但能提高并发度，因为不同线程可以同时访问不同部分的资源。
- 死锁检测机制：JVM自带工具如 jstack 和 VisualVM 简单易用，对于发现死锁非常有效。自定义工具基于线程和锁监控，能够实时或定期检测死锁，并且可以根据实际需求进行定制化配置。
扩展性
- 锁策略优化：这些策略具有良好的扩展性。无论是增加新的服务还是线程，只要遵循相同的锁使用原则，都能有效预防死锁。例如，新的服务模块如果需要访问共享资源，按照既定的锁获取顺序和锁粒度控制原则进行编码，不会引入新的死锁风险。
- 死锁检测机制：JVM自带工具在扩展性方面有一定局限性，主要用于单机环境下的进程分析。而自定义工具可以通过分布式监控架构进行扩展。例如，在分布式系统中，可以在每个节点上运行一个死锁检测代理，将检测数据汇总到一个中心节点进行分析，从而实现对整个分布式系统的死锁检测。

星途面试题库

面试题：设计一个复杂场景下Java死锁预防与检测的方案

知识考点

面试题答案

代码层面的锁策略优化

运行时的死锁检测机制

方案在高并发、多线程且资源竞争激烈场景下的可行性与扩展性