Java并发编程中常见的死锁问题案例

原创清疚 2024-10-25 03:27 39阅读 0赞

在Java并发编程中，死锁是一种严重的问题，它会导致所有等待资源的线程无法继续执行。下面是一个经典的死锁案例：

案例：银行系统

假设有一个银行的转账系统，如下两个类分别代表两个账户：

1. Account类：
```java
public class Account {
    private String name;
    private int balance;

// 构造器
    public Account(String name, int initialBalance) {
        this.name = name;
        this.balance = initialBalance;
    }

// 获取和设置方法
    public String getName() {
        return name;
    }

public void setName(String name) {
        this.name = name;
    }

public int getBalance() {
        return balance;
    }

public void setBalance(int balance) {
        this.balance = balance;
    }
}
```

2. Bank类：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Bank {
    private Map<Account, Lock> locks; // 锁对象，使用ReentrantLock

// 构造器
    public Bank() {
        this.locks = new HashMap<>();
    }

// 为账户提供转账服务
    public void transfer(Account from, Account to, int amount) throws InterruptedException {
        // 获取from账户的锁
        Lock lockFrom = locks.get(from);
        if (lockFrom == null) {
            throw new RuntimeException("Failed to acquire lock for account " + from.getName());
        }

// 设置锁为非阻塞模式，以提高转账效率
        lockFrom.lockInterruptibly();

try {
            // 转账逻辑
            from.setBalance(from.getBalance() - amount);
            to.setBalance(to.getBalance() + amount);

System.out.println("Transfer successful: " + from.getName() + " -> " + to.getName() + " with " + amount + " units"));

} catch (Exception e) {
            // 处理转账过程中可能出现的异常
            lockFrom.unlock();
            throw new RuntimeException("Transfer failed for account " + from.getName(), e);
        }
    }

// 获取账户锁
    public Lock getLockForAccount(Account account) {
        return locks.get(account);
    }
}
```

在这个案例中，账户A和账户B互为转账对象。在`Bank`类的`transfer`方法中，我们使用了锁（`Lock`）来确保转账过程的安全性。

当两个线程同时调用`transfer`方法对同一个账户进行转账时，如果没有锁，可能会导致数据不一致的问题，从而产生死锁现象。