多线程同步问题：Java并发编程中的死锁示例

原创客官°小女子只卖身不卖艺 2024-12-03 21:30 17阅读 0赞

在Java并发编程中，死锁是一种常见的线程同步问题。以下是一个典型的死锁示例：

假设我们有两个类，Banker 和 Customer。

1. Banker类：
```java
public class Banker implements Runnable {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

public void doSomething() throws InterruptedException {
        // 避免并发访问锁
        synchronized (lock1) {
            // 互斥操作
            synchronized (lock2) {
                // 两个线程同时执行doSomething()
                System.out.println("Banker is doing something ...");
                Thread.sleep(500); // 模拟耗时操作
                System.out.println("Banker has finished doing something ...");

// 唤醒锁1，然后等待锁2释放
                lock1.notifyAll();
            }
        }

// 在最后释放锁
        synchronized (lock2) {
            lock2.notifyAll();
        }
    }

@Override
    public void run() {
        try {
            Banker().doSomething();
        } catch (InterruptedException e) {
            System.out.println("Banker was interrupted ...");
            e.printStackTrace();
        } finally {
            System.out.println("Banker's run method finished ...");
        }
    }
}
```

2. Customer类：
```java
public class Customer implements Runnable {
    private final Object lock1 = new Object();

public void doSomething() throws InterruptedException {
        // 避免并发访问锁
        synchronized (lock1) {
            System.out.println("Customer is waiting to do something ...");

// 等待Banker释放锁
            lock1.wait();
        }

System.out.println("Customer has finished doing something ...");
    }

@Override
    public void run() {
        try {
            Customer().doSomething();
        } catch (InterruptedException e) {
            System.out.println("Customer was interrupted ...");
            e.printStackTrace();
        } finally {
            System.out.println("Customer's run method finished ...");
        }
    }
}
```

当两个线程（Banker和Customer）按照以下步骤运行时，就会发生死锁：

1. Banker线程请求lock1。
2. Customer线程请求lock1。
3. Banker释放lock1（因为同步块内无其他锁定操作）。
4. lock1被Customer线程抢占，而Banker仍持有lock2未解锁。
5. Customer尝试释放lock1（因为它是wait()方法唤醒的条件），但Banker锁住此资源，导致循环无法自解。

在实际编程中，避免死锁的一种策略是使用超时机制、设置最大重试次数或者使用线程池来管理线程。