理解和解决Java并发编程中的死锁问题实例

原创亦凉 2024-09-27 18:45 87阅读 0赞

死锁是Java并发编程中的一种严重问题，当两个或更多的线程互相等待对方释放资源时，就会发生死锁。

以下是一个简单的Java死锁例子：

```java
// 创建两个互有依赖的类
class BankAccount {
    int amount;
    BankAccount(int amount) { this.amount = amount; }
    void withdraw(int amount) { if (amount > this.amount)) throw new IllegalArgumentException("Insufficient funds"); this.amount -= amount; }
}

class LoanApplication {
    BankAccount account;
    double loanAmount;

LoanApplication(BankAccount account, double loanAmount) {
        this.account = account;
        this.loanAmount = loanAmount;
    }

void applyForLoan() {
        withdraw(loanAmount);
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount bankAccount1 = new BankAccount(50);
        BankAccount bankAccount2 = new BankAccount(100);

LoanApplication loanApplication1 = new LoanApplication(bankAccount1, 20));
        LoanApplication loanApplication2 = new LoanApplication(bankAccount2, 30));

// 线程开始请求资源
        Thread thread1 = new Thread(loanApplication1::applyForLoan));
        Thread thread2 = new Thread(loanApplication2::applyForLoan));

// 同时开始线程，可能会导致死锁
        thread1.start();
        thread2.start();

try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，两个类（BankAccount和LoanApplication）互相依赖，形成一个资源链。两个线程分别申请了这条链的一部分资源。

如果这两个线程的执行顺序是：先请求`loanApplication2::applyForLoan`，然后请求`loanApplication1::applyForLoan`；并且两个请求都需要对方释放资源，那么就会发生死锁。