Java多线程实践：死锁问题

原创深碍√TFBOYSˉ_ 2024-10-11 20:54 60阅读 0赞

在Java多线程编程中，死锁是一个常见的并发问题。简单来说，当两个或更多的线程相互等待对方释放资源时，就会发生死锁。

以下是一些关于死锁的Java实现示例：

1. **基本条件**：
   - 互斥：同一时刻只有一个线程访问共享资源。
   - 不剥夺：一旦某个线程获得了资源，它就不能被剥夺。
   - 环路等待：当多个线程互相等待对方释放资源时，就会形成一个环形等待链。

2. **Java代码示例**：
   ```java
   // 假设我们有两个线程，分别需要资源A和B
   class Thread1 implements Runnable {
       private Object resourceA;

public Thread1(Object resourceA) {
           this.resourceA = resourceA;
       }

@Override
       public void run() {
           // 获取资源A，然后等待资源B
           synchronized (resourceA) {
               System.out.println("Thread 1: Acquiring A...");

resourceA.notifyAll(); // 通知所有等待资源B的线程

System.out.println("Thread 1: Waiting for B...");

try {
                   // 等待资源B，如果被中断，则恢复
                   resourceB.wait();
               } catch (InterruptedException e) {
                   // 如果线程被中断，恢复资源B
                   resourceB.notifyAll();
                   Thread.currentThread().interrupt(); // 恢复中断状态
                   e.printStackTrace();
               }

System.out.println("Thread 1: B acquired, releasing A...");

synchronized (resourceA) {
                   resourceA.notifyAll(); // 通知所有等待资源A的线程
                   resourceA.unlock(); // 释放资源A，允许其他线程获取
                   System.out.println("Thread 1: A released.");
               }
           }
       }
   }

class Thread2 implements Runnable {
       private Object resourceB;

public Thread2(Object resourceB) {
           this.resourceB = resourceB;
       }

@Override
       public void run() {
           // 获取资源B，然后等待资源A
           synchronized (resourceB) {
               System.out.println("Thread 2: Acquiring B...");

resourceB.notifyAll(); // 通知所有等待资源A的线程

System.out.println("Thread 2: Waiting for A...");

try {
                   // 等待资源A，如果被中断，则恢复
                   resourceA.wait();
               } catch (InterruptedException e) {
                   // 如果线程被中断，恢复资源A
                   resourceA.notifyAll();
                   Thread.currentThread().interrupt(); // 恢复中断状态
                   e.printStackTrace();
               }

System.out.println("Thread 2: A acquired, releasing B...");

synchronized (resourceB) {
                   resourceB.notifyAll(); // 通知所有等待资源B的线程
                   resourceB.unlock(); // 释放资源B，允许其他线程获取
                   System.out.println("Thread 2: B released.");
               }
           }
       }
   }

public static void main(String[] args) {
       Thread1 thread1 = new Thread1(new Object()); // 创建线程1并为其分配资源B的副本
       Thread2 thread2 = new Thread2(new Object()); // 创建线程2并为其分配资源A的副本

thread1.start(); // 启动线程1
       thread2.start(); // 启动线程2

try {
           // 等待所有线程完成执行
           while (thread1.isAlive() || thread2.isAlive()) {
               Thread.sleep(100); // 暂停一段时间，观察线程状态变化
           }
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
```

在这个例子中，我们创建了两个相互等待的多线程场景。每个线程分别需要资源A和B，并通过wait()和notifyAll()方法实现同步。

当主线程启动这两个线程后，它们会按照预定的顺序进行交互。最终，所有线程都完成执行后，主线程才会继续运行。