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

原创「爱情、让人受尽委屈。」 2024-12-09 15:09 13阅读 0赞

在Java多线程编程中，死锁是一个常见的并发问题。以下是一个简单的死锁示例：

```java
// 创建两个资源类
class ResourceA {
    int count = 10;
    boolean isAvailable = true;

public synchronized void acquire() {
        if (isAvailable) {
            count--;
            isAvailable = false;
            System.out.println("Resource A acquired by thread " + Thread.currentThread().getName());
        } else {
            System.out.println("Thread " + Thread.currentThread().getName() + " tried to acquire Resource A but it's not available");
        }
    }

public synchronized void release() {
        if (count > 0) {
            count++;
            isAvailable = true;
            System.out.println("Resource A released by thread " + Thread.currentThread().getName());
        } else {
            System.out.println("Thread " + Thread.currentThread().getName() + " tried to release Resource A but it's already in use");
        }
    }
}

class ResourceB {
    int count = 10;
    boolean isAvailable = true;

public synchronized void acquire() {
        if (isAvailable) {
            count--;
            isAvailable = false;
            System.out.println("Resource B acquired by thread " + Thread.currentThread().getName());
        } else {
            System.out.println("Thread " + Thread.currentThread().getName() + " tried to acquire Resource B but it's not available");
        }
    }

public synchronized void release() {
        if (count > 0) {
            count++;
            isAvailable = true;
            System.out.println("Resource B released by thread " + Thread.currentThread().getName());
        } else {
            System.out.println("Thread " + Thread.currentThread().getName() + " tried to release Resource B but it's already in use");
        }
    }
}

public class DeadlockExample {
    private static ResourceA resourceA = new ResourceA();
    private static ResourceB resourceB = new ResourceB();

public static void main(String[] args) {
        // 创建线程并启动
        Thread thread1 = new Thread(() -> acquireResource(resourceA, "Thread 1")));
        Thread thread2 = new Thread(() -> acquireResource(resourceB, "Thread 2"))));
        thread1.start();
        thread2.start();

try {
            // 等待所有线程执行完毕
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            System.out.println("Thread interruption occurred during join operation");
            e.printStackTrace();
        }
    }

private static void acquireResource(Resource resource, String threadName) {
        try {
            // 调用资源的获取方法，需要同步以避免数据不一致
            synchronized (resource) {
                if (!resource.isAvailable()) {
                    System.out.println("Thread " + threadName + " tried to acquire Resource but it's already in use by another thread");
                    return;
                }

resource.acquire();
                System.out.println("Resource acquired by thread " + threadName);
            }
        } catch (Exception e) {
            System.out.println("Error occurred while acquiring resource for thread " + threadName);
            e.printStackTrace();
        }
    }
}
```

在这个例子中，资源A和资源B都有相同的计数器（count）和是否可用的状态（isAvailable）。线程1尝试获取资源A，同时线程2尝试获取资源B。如果任何一个线程试图获取已被另一个线程占用的资源，就会发生死锁。

要避免这种情况，通常的做法是按照特定的顺序获取资源，或者使用超时机制防止长时间等待。