Java并发编程：线程死锁示例

原创古城微笑少年丶 2024-10-11 21:36 73阅读 0赞

线程死锁是并发编程中的一个常见问题。简单来说，当两个或更多的线程因争夺资源而造成的一种互相等待的现象时，就会发生死锁。

下面是一个典型的Java线程死锁示例：

```java
// 创建两个互斥资源的类
class Lock {
    boolean locked = false;
    
    // 获取锁
    synchronized void lock() {
        if (locked) {
            throw new RuntimeException("Lock is already locked!");
        }
        locked = true;
    }
    
    // 释放锁
    synchronized void unlock() {
        if (!locked) {
            throw new RuntimeException("Lock is not locked!");
        }
        locked = false;
    }
}

// 线程A需要资源1的锁，线程B需要资源2的锁，但是它们各自获得的锁是对方需要的资源
class ThreadA extends Thread {
    private Lock lock1;
    
    public ThreadA(Lock lock1) {
        this.lock1 = lock1;
    }
    
    @Override
    public void run() {
        try {
            // 线程A先获取资源2的锁
            lock1.lock();
            
            // 在获得资源1的锁后，线程A开始执行自己的代码
            System.out.println("Thread A executing resource 1...");
            
            // 线程A释放资源2的锁
            lock1.unlock();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread {
    private Lock lock2;
    
    public ThreadB(Lock lock2) {
        this.lock2 = lock2;
    }
    
    @Override
    public void run() {
        try {
            // 线程B先获取资源1的锁
            lock2.lock();
            
            // 在获得资源2的锁后，线程B开始执行自己的代码
            System.out.println("Thread B executing resource 2...");
            
            // 线程B释放资源1的锁
            lock2.unlock();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 主程序，创建并启动两个需要互斥资源的线程
public class Main {
    public static void main(String[] args) {
        Lock lock1 = new Lock();
        Lock lock2 = new Lock();

ThreadA threadA = new ThreadA(lock1);
        ThreadB threadB = new ThreadB(lock2);

// 启动线程
        threadA.start();
        threadB.start();
    }
}
```

在这个示例中，线程A需要资源1的锁，同时线程B需要资源2的锁。当两个线程各自获取了对方需要的锁时，它们就会陷入死锁状态，无法继续执行任务。