Java中死锁问题及解决方法

2025-12-04 09:02:20 作者：阿黄学技术

本文主要介绍了Java中死锁问题及解决方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

什么是死锁

死锁(Deadlock)是指两个或多个线程在执行过程中，因为争夺资源而造成的一种互相等待的现象，导致这些线程都无法继续执行下去。

死锁产生的四个必要条件：

互斥条件：资源一次只能由一个线程占用
请求与保持条件：线程在持有至少一个资源的同时又请求其他被占用的资源
不剥夺条件：已分配给线程的资源不能被其他线程强行夺取
循环等待条件：存在一个线程等待的循环链

Java中死锁示例

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

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread1 holds lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread1 waiting for lock2");
                synchronized (lock2) {
                    System.out.println("Thread1 holds lock1 and lock2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread2 holds lock2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread2 waiting for lock1");
                synchronized (lock1) {
                    System.out.println("Thread2 holds lock1 and lock2");
                }
            }
        });

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

解决死锁的方法

1. 避免嵌套锁

尽量减少锁的嵌套使用，或者确保所有线程以相同的顺序获取锁。

// 修改后的代码 - 确保相同的锁获取顺序
Thread thread1 = new Thread(() -> {
    synchronized (lock1) {
        synchronized (lock2) {
            // 操作资源
        }
    }
});

Thread thread2 = new Thread(() -> {
    synchronized (lock1) {
        synchronized (lock2) {
            // 操作资源
        }
    }
});

2. 使用定时锁

使用tryLock()方法尝试获取锁，如果获取不到则释放已持有的锁。

Lock lock1 = new ReentrantLock();
Lock lock2 = new ReentrantLock();

public void method() {
    while(true) {
        if(lock1.tryLock()) {
            try {
                if(lock2.tryLock()) {
                    try {
                        // 执行操作
                        break;
                    } finally {
                        lock2.unlock();
                    }
                }
            } finally {
                lock1.unlock();
            }
        }
        // 随机休眠避免活锁
        Thread.sleep((long)(Math.random() * 100));
    }
}

3. 使用更高级的并发工具

使用java.util.concurrent包中的高级工具如Semaphore、CountDownLatch等。

4. 死锁检测与恢复

可以通过线程转储(Thread Dump)来检测死锁：

使用jstack工具：jstack <pid>
使用JMX：ThreadMXBean.findDeadlockedThreads()

5. 设置锁超时

if(lock.tryLock(100, TimeUnit.MILLISECONDS)) {
    try {
        // 访问共享资源
    } finally {
        lock.unlock();
    }
} else {
    // 未能获取锁的处理逻辑
}

预防死锁的最佳实践

尽量使用无锁设计或不可变对象
减少锁的作用范围和时间
避免在一个方法中获取多个锁
如果必须获取多个锁，确保所有线程以相同的顺序获取锁
使用并发集合类而非同步集合类
考虑使用读写锁(ReentrantReadWriteLock)替代互斥锁

通过合理的设计和遵循这些原则，可以有效地避免Java程序中的死锁问题。

到此这篇关于Java中死锁问题及解决方法的文章就介绍到这了,更多相关Java 死锁问题内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！