Java死锁实现

本文通过一个具体的Java代码示例,演示了当两个线程分别持有不同的锁并尝试获取对方持有的锁时,如何发生死锁的情况。代码中定义了两个字符串锁'lock1'和'lock2',并在两个线程中交替使用这两个锁,导致了死锁的发生。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

public class Main {
    public static void main(String[] args) {
        String lock1 = "lock1";
        String lock2 = "lock2";
        new Person(lock1, lock2).start();
        new Person(lock2, lock1).start();
    }
}

class Person extends Thread {
    String lock1;
    String lock2;

    public Person(String lock1, String lock2) {
        this.lock1 = lock1;
        this.lock2 = lock2;
    }

    @Override
    public void run() {
        synchronized (lock1) {
            System.out.println(Thread.currentThread().getName() + "----" + lock1);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (lock2) {
                System.out.println(Thread.currentThread().getName() + "----" + lock2);
            }
        }
    }
}
### Java死锁实现方式及原理 #### 死锁的概念 死锁是指两个或多个线程互相持有对方所需的资源,从而导致这些线程都处于无限期等待的状态。这种情况通常发生在多线程环境中,当线程试图获取已被其他线程占用的资源时发生[^2]。 #### 死锁产生的必要条件 要形成死锁,必须满足以下四个条件: 1. **互斥**:资源只能由一个线程独占使用。 2. **占有并等待**:某个线程已持有一个资源的同时又申请新的资源。 3. **非抢占**:已分配的资源不能强制剥夺,只有拥有者主动释放。 4. **循环等待**:存在一组线程{A, B},其中 A 等待 B 的资源,而 B 同时也等待 A 的资源[^3]。 #### 示例代码展示死锁现象 下面是一个典型的死锁场景示例: ```java public class DeadlockExample { private static final Object lock1 = new Object(); private static final Object lock2 = new Object(); public static void main(String[] args) throws InterruptedException { Thread thread1 = new Thread(() -> { synchronized (lock1) { // 获取第一个锁 System.out.println("Thread 1: Holding lock 1..."); try { Thread.sleep(100); // 让另一个线程有机会运行 } catch (InterruptedException e) {} System.out.println("Thread 1: Waiting for lock 2..."); synchronized (lock2) { // 尝试获取第二个锁 System.out.println("Thread 1: Holding lock 1 & 2"); } } }); Thread thread2 = new Thread(() -> { synchronized (lock2) { // 获取第二个锁 System.out.println("Thread 2: Holding lock 2..."); try { Thread.sleep(100); } catch (InterruptedException e) {} System.out.println("Thread 2: Waiting for lock 1..."); synchronized (lock1) { // 尝试获取第一个锁 System.out.println("Thread 2: Holding lock 1 & 2"); } } }); thread1.start(); // 启动线程 1 thread2.start(); // 启动线程 2 } } ``` 在这个例子中,`thread1` 和 `thread2` 都尝试按相反顺序锁定相同的两把锁 (`lock1` 和 `lock2`)。这会导致它们陷入相互等待的状态,最终造成死锁[^5]。 --- #### 解决方案 ##### 方法一:避免嵌套锁 通过确保所有线程按照一致的顺序获取锁来消除潜在的死锁风险。例如,在上述代码中可以修改为始终先获取 `lock1` 再获取 `lock2`。 ```java synchronized(lock1){ synchronized(lock2){ // 执行操作... } } ``` 这种方法能够打破“占有并等待”的条件。 ##### 方法二:设置超时机制 利用 `Lock` 接口提供的带时间限制的方法(如 `tryLock()`),可以在一定时间内未能成功获得锁时放弃当前请求。 ```java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class TimeoutDeadlockSolution { private static final Lock lock1 = new ReentrantLock(); private static final Lock lock2 = new ReentrantLock(); public static void main(String[] args) { Thread t1 = new Thread(() -> { boolean lockedFirst = false; boolean lockedSecond = false; try { lockedFirst = lock1.tryLock(100, TimeUnit.MILLISECONDS); if (!lockedFirst) return; // 如果未得到锁则退出 lockedSecond = lock2.tryLock(100, TimeUnit.MILLISECONDS); if (!lockedSecond) { lock1.unlock(); // 若第二把锁失败,则解锁第一把 return; } // 成功加锁后的逻辑处理... } catch (Exception ex) {} finally { if (lockedFirst && lockedSecond) { lock1.unlock(); lock2.unlock(); } } }); t1.start(); } } ``` 此方法可防止因长时间阻塞而导致的死锁情况[^4]。 ##### 方法三:引入死锁检测与恢复机制 借助外部工具(如 `jstack` 或 `VisualVM`)监控线程状态,及时发现问题所在,并采取措施解除僵局。例如定期检查是否有线程长期停滞不前,一旦发现异常即刻中断部分线程以恢复正常运作流程。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值