Java并发编程：防范死锁（锁排序，锁超时，死锁检测）

用心去追梦

于 2024-08-15 11:16:59 发布

阅读量332

点赞数 4

文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/qq_33240556/article/details/141217638

版权

防范死锁是Java并发编程中非常重要的一部分，它涉及多种策略和技术来避免或减少死锁的发生。下面我将详细介绍几种防范死锁的方法，包括锁排序、锁超时和死锁检测。

锁排序（Lock Ordering）

定义：
锁排序是一种预防死锁的技术，它要求所有的线程按照相同的顺序获取锁。

特点：

顺序一致：所有线程按照相同的顺序获取锁。
简单有效：可以显著减少死锁的发生。

示例：

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

    public void method1() {
        synchronized (lock1) {
            synchronized (lock2) {
                // 代码逻辑
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            synchronized (lock1) {
                // 代码逻辑
            }
        }
    }

    public static void main(String[] args) {
        LockOrderingExample example = new LockOrderingExample();
        Thread threadA = new Thread(() -> example.method1());
        Thread threadB = new Thread(() -> example.method2());

        threadA.start();
        threadB.start();
    }
}

在这个示例中，method1和method2分别按照不同的顺序获取锁lock1和lock2。如果多个线程以不同的顺序获取锁，就有可能发生死锁。为了避免这种情况，我们应该始终按照相同的顺序获取锁。

锁超时（Lock Timeout）

定义：
锁超时是指在尝试获取锁时设置一个超时时间，如果在规定的时间内无法获取锁，则放弃尝试。

特点：

避免无限等待：如果无法获取锁，线程可以继续执行其他任务。
减少死锁：可以减少死锁的发生概率。

示例：

public class LockTimeoutExample {
    private final ReentrantLock lock1 = new ReentrantLock();
    private final ReentrantLock lock2 = new ReentrantLock();

    public void method1() {
        if (lock1.tryLock(500, TimeUnit.MILLISECONDS)) {
            try {
                if (lock2.tryLock(500, TimeUnit.MILLISECONDS)) {
                    try {
                        // 代码逻辑
                    } finally {
                        lock2.unlock();
                    }
                }
            } finally {
                lock1.unlock();
            }
        }
    }

    public void method2() {
        if (lock2.tryLock(500, TimeUnit.MILLISECONDS)) {
            try {
                if (lock1.tryLock(500, TimeUnit.MILLISECONDS)) {
                    try {
                        // 代码逻辑
                    } finally {
                        lock1.unlock();
                    }
                }
            } finally {
                lock2.unlock();
            }
        }
    }

    public static void main(String[] args) {
        LockTimeoutExample example = new LockTimeoutExample();
        Thread threadA = new Thread(() -> example.method1());
        Thread threadB = new Thread(() -> example.method2());

        threadA.start();
        threadB.start();
    }
}

在这个示例中，我们使用了ReentrantLock类的tryLock方法来尝试获取锁，并设置了超时时间。如果在规定的时间内无法获取锁，则线程将继续执行其他任务，从而减少了死锁的可能性。

死锁检测

定义：
死锁检测是指在运行时检测是否存在死锁，并采取相应的措施来解除死锁。

特点：

动态检测：在运行时检测死锁的存在。
解除死锁：一旦检测到死锁，可以采取措施来解除死锁。

示例：
Java标准库并没有直接提供死锁检测的API，但是可以通过一些间接的方式来检测死锁。例如，使用ThreadMXBean来获取死锁信息。

public class DeadlockDetectionExample {
    private final ReentrantLock lock1 = new ReentrantLock();
    private final ReentrantLock lock2 = new ReentrantLock();

    public void method1() {
        lock1.lock();
        try {
            lock2.lock();
            try {
                // 代码逻辑
            } finally {
                lock2.unlock();
            }
        } finally {
            lock1.unlock();
        }
    }

    public void method2() {
        lock2.lock();
        try {
            lock1.lock();
            try {
                // 代码逻辑
            } finally {
                lock1.unlock();
            }
        } finally {
            lock2.unlock();
        }
    }

    public static void main(String[] args) {
        DeadlockDetectionExample example = new DeadlockDetectionExample();
        Thread threadA = new Thread(() -> example.method1());
        Thread threadB = new Thread(() -> example.method2());

        threadA.start();
        threadB.start();

        // 使用ThreadMXBean来检测死锁
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
        if (deadlockedThreads != null) {
            ThreadInfo[] deadlockedThreadInfo = threadMXBean.getThreadInfo(deadlockedThreads);
            for (ThreadInfo info : deadlockedThreadInfo) {
                System.out.println("Deadlocked thread: " + info.getThreadName());
            }
        }
    }
}