Java多线程同步问题：死锁与唤醒策略示例

原创朴灿烈づ我的快乐病毒、 2024-09-28 00:12 63阅读 0赞

在Java中，多线程可能会遇到死锁和唤醒策略的问题。这里我们将通过一个简单的示例来说明这两种情况。

1. 死锁示例（两个线程相互等待资源）

```java
// 创建两个互斥的资源
class Resource {
    int count;
    boolean available = true;

synchronized void request() {
        while (!available) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count++;
        System.out.println("Resource " + this + " requested by thread " + Thread.currentThread().getName());

// 检查资源是否可用
        available = count == 1;
        synchronized (this) {
            if (available) {
                notifyAll();
            } else {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

class ThreadA extends Thread {
        Resource resource;

ThreadA(Resource r) {
            this.resource = r;
        }

@Override
        public void run() {
            resource.request(); // 线程A请求资源
            try {
                // 等待线程B释放资源
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 线程A尝试再次请求资源
            resource.request();
        }
    }

class ThreadB extends Thread {
        Resource resource;

ThreadB(Resource r) {
            this.resource = r;
        }

@Override
        public void run() {
            while (resource.count != 0) { // 线程B保持资源不被释放
                try {
                    // 等待线程A请求资源
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

// 线程B释放资源
            resource.count = 1;
        }
    }

public static void main(String[] args) {
        Resource resource = new Resource();

ThreadA threadA = new ThreadA(resource);
        ThreadB threadB = new ThreadB(resource);

threadA.start();
        threadB.start();

// 线程主线程等待所有线程结束
        try {
            while (true) {
                // 如果所有线程都已结束，则退出循环
                if (!threadA.isAlive() && !threadB.isAlive()) {
                    break;
                }
                // 线程主线程睡眠一段时间，避免CPU占用过高
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

// 释放资源
        resource = null;

System.out.println("All threads have finished.");
    }
}
```

在这个示例中，线程A和线程B分别请求和释放一个资源。如果线程B在资源被完全释放之前一直保持资源不被释放，那么线程A将无法再次请求资源，从而导致死锁。

通过设置适当的唤醒策略（如在此示例中的等待一段时间），可以避免这种死锁情况的发生。