Java多线程同步问题示例：死锁与活锁

原创约定不等于承诺〃 2024-10-06 12:00 88阅读 0赞

在Java多线程编程中，线程之间的同步问题是常见的挑战，其中包括死锁和活锁。

1. 死锁（Deadlock）：
   - 描述：当两个或更多的线程互相等待对方释放资源时，就形成了死锁。
   - 示例代码：
   ```java
   // 线程1，持有资源A
   class ResourceA {
       private Object lock = new Object();

void acquire() synchronized(lock) {
           if (isAvailable()) {
               acquired();
           } else {
               wait();
           }
       }

private boolean isAvailable() {
           // 这里假设资源可用情况
           return true;
       }

void released() synchronized(lock) {
           if (!isAvailable()) {
               resume();
           } else {
               unwait();
           }
       }

private void resumed() {
           // 这里假设资源恢复操作
       }

private void unwaited() {
           // 这里假设资源释放后唤醒操作
       }
   }

class ThreadA extends Thread {
       ResourceA resourceA;
       boolean acquired = false;

ThreadA(ResourceA resource) {
           this.resourceA = resource;
           start();
       }

@Override
       public void run() {
           try {
               // 线程A获取资源A的锁
               if (!resourceA.acquire()) {
                   System.out.println("线程A尝试获取资源A失败");
                   return;
               }
               System.out.println("线程A成功获取资源A");

// 这里假设需要其他线程帮助完成的操作
               ThreadB threadB = new ThreadB(resourceA);
               threadB.start();

// 线程A释放资源A的锁
               resourceA.released();
           } catch (Exception e) {
               System.out.println("线程A运行过程中出现异常：" + e.getMessage());
           }
       }
   }

class ThreadB extends Thread {
       ResourceA resourceA;
       boolean acquired = false;

ThreadB(ResourceA resource) {
           this.resourceA = resource;
           start();
       }

@Override
       public void run() {
           try {
               // 线程B尝试获取资源A的锁
               if (!resourceA.acquire()) {
                   System.out.println("线程B尝试获取资源A失败");
                   return;
               }
               System.out.println("线程B成功获取资源A");

// 这里假设需要其他线程帮助完成的操作，如同步操作
               ThreadA threadA = new ThreadA(resourceA);
               threadA.start();

// 线程B释放资源A的锁
               resourceA.released();
           } catch (Exception e) {
               System.out.println("线程B运行过程中出现异常：" + e.getMessage());
           }
       }
   }

public class Main {
       public static void main(String[] args) {
           // 创建资源A对象并初始化线程A
           ResourceA resourceA = new ResourceA();
           ThreadA threadA = new ThreadA(resourceA);

// 启动线程A
           threadA.start();

// 创建资源A对象并初始化线程B
           ResourceA resourceB = new ResourceA();
           ThreadB threadB = new ThreadB(resourceB);

// 启动线程B
           threadB.start();
       }
   }
}
```
在这个示例中，两个线程`ThreadA`和`ThreadB`都试图获取资源`ResourceA`。但是资源只能被一个线程持有，这就可能导致死锁。

例如，`ThreadA`首先获取资源，然后开始等待释放锁，这时候如果`ThreadB`尝试获取资源而不能成功（比如因为`ThreadA`已经获得并锁定资源），那么`ThreadB`就会一直等待`ThreadA`释放锁，这样就形成了死锁。