死锁产生的原因及Java中的应对方法

普通网友

墨衍会员 · AI 创作全网分发码龄3年

关注

原创最新推荐文章于 2026-01-29 19:34:50 发布 378 阅读 AI 写同款· GEO 优化 ›

MySQL死锁产生的原因和解决方法线程安全问题以及MySQL死锁产生的原因和解决方法排查方法和案例分析阅读详情

死锁是多线程编程中常见的问题，它发生在两个或多个线程相互等待对方所持有的资源而无法继续执行的情况。当死锁发生时，程序将无法继续执行，造成系统资源的浪费和性能下降。在Java中，我们可以采取一些方法来预防和解决死锁问题。

首先，让我们来了解一下死锁产生的常见原因：

互斥条件（Mutual Exclusion）：一个资源一次只能被一个线程持有。如果一个线程已经获得了某个资源，其他线程就无法再次获得该资源，只能等待该资源的释放。
请求与保持条件（Hold and Wait）：一个线程在持有某个资源的同时又请求其他线程所持有的资源。如果所有线程都持有至少一个资源，并且又在等待其他资源，就可能发生死锁。
不可剥夺条件（No Preemption）：已经分配给线程的资源不能被强制性地剥夺，只能由持有资源的线程显式地释放。
循环等待条件（Circular Wait）：存在一个线程和资源的循环等待链，每个线程都在等待下一个线程所持有的资源。

要避免死锁，我们可以应用以下策略：

避免使用多个锁：尽量减少使用多个锁，尽量使用一个锁或者使用更高级别的同步机制，如并发集合类。这样可以减少死锁的发生。
破坏循环等待条件：通过对资源的有序分配，破坏线程和资源之间的循环等待关系。可以使用资源排序算法来实现资源的有序分配。
使用定时锁：使用tryLock()方法来获取锁，并设置超时时间。这样如果在超时时间内无法获取到锁，线程可以放弃锁并继续执行其他操作，避免一直等待造成死锁。

下面是一个示例代码，演示了死锁的产生和应对方法：

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

public class DeadlockExample {
    private static final Lock lock1 = new ReentrantLock();
    private static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                lock1.lock();
                Thread.sleep(100); // 为了产生死锁，让线程1先获取lock1再获取lock2
                lock2.lock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock1.unlock();
                lock2.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                lock2.lock();
                Thread.sleep(100); // 为了产生死锁，让线程2先获取lock2再获取lock1
                lock1.lock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock2.unlock();
                lock1.unlock();
            }
        });

        thread1.start();
        thread2.start();
    }
}

在上面的示例中，两个线程分别尝试获取lock1和lock2，并且顺序相反，这会导致死锁的发生。为了避免死锁，我们可以尝试使用tryLock()方法并设置超时时间，代码示例如下：

Thread thread1 = new Thread(() -> {
    try {
        if (lock1.tryLock()) {
            Thread.sleep(100); // 为了产生死锁，让线程1先获取lock1再获取lock2
            if (lock2.tryLock()) {
                // 执行死锁产生的原因及Java中的应对方法

死锁是多线程编程中常见的问题，它发生在两个或多个线程相互等待对方所持有的资源而无法继续执行的情况。当死锁发生时，程序将无法继续执行，造成系统资源的浪费和性能下降。在Java中，我们可以采取一些方法来预防和解决死锁问题。

首先，让我们来了解一下死锁产生的常见原因：

1. 互斥条件（Mutual Exclusion）：一个资源一次只能被一个线程持有。如果一个线程已经获得了某个资源，其他线程就无法再次获得该资源，只能等待该资源的释放。

2. 请求与保持条件（Hold and Wait）：一个线程在持有某个资源的同时又请求其他线程所持有的资源。如果所有线程都持有至少一个资源，并且又在等待其他资源，就可能发生死锁。

3. 不可剥夺条件（No Preemption）：已经分配给线程的资源不能被强制性地剥夺，只能由持有资源的线程显式地释放。

4. 循环等待条件（Circular Wait）：存在一个线程和资源的循环等待链，每个线程都在等待下一个线程所持有的资源。

要避免死锁，我们可以应用以下策略：

1. 避免使用多个锁：尽量减少使用多个锁，尽量使用一个锁或者使用更高级别的同步机制，如并发集合类。这样可以减少死锁的发生。

2. 破坏循环等待条件：通过对资源的有序分配，破坏线程和资源之间的循环等待关系。可以使用资源排序算法来实现资源的有序分配。

3. 使用定时锁：使用`tryLock()`方法来获取锁，并设置超时时间。这样如果在超时时间内无法获取到锁，线程可以放弃锁并继续执行其他操作，避免一直等待造成死锁。

下面是一个示例代码，演示了死锁的产生和应对方法：

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

public class DeadlockExample {
    private static final Lock lock1 = new ReentrantLock();
    private static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                lock1.lock();
                Thread.sleep(100); // 为了产生死锁，让线程1先获取lock1再获取lock2
                lock2.lock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock1.unlock();
                lock2.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                lock2.lock();
                Thread.sleep(100); // 为了产生死锁，让线程2先获取lock2再获取lock1
                lock1.lock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock2.unlock();
                lock1.unlock();
            }
        });

        thread1.start();
        thread2.start();
    }
}

Thread thread1 = new Thread(() -> {
    try {
        if (lock1.tryLock()) {
            Thread.sleep(100); // 为了产生死锁，让线程1先获取lock1再获取lock2
            if (lock2.tryLock()) {
                // 执行