Java并发编程中常见问题：案例解析

原创柔情只为你懂 2024-10-07 16:42 62阅读 0赞

在Java并发编程中，常见的问题包括线程安全、死锁、资源泄漏、同步原语使用不当等。下面通过几个案例来解析这些问题。

1. 线程安全：
   **示例**：
   ```java
   class Counter {
       private int count = 0;
       
       public synchronized void increment() {
           count++;
           notifyAll();
       }
       
       public synchronized int decrementIfZero() {
           if (count == 0) {
               count--;
               wait();
               return 0;
           } else {
               count--;
               return 1;
           }
       }
   }
   ```
   **解析**：
   - `synchronized`关键字保证了方法的线程安全。
   - 在`increment()`方法中，先将计数器加1，然后唤醒所有等待的线程，防止死锁。

2. 死锁：
   **示例**：
   ```java
   class BankAccount {
       private String accountNumber;
       
       public BankAccount(String accountNumber) {
           this.accountNumber = accountNumber;
       }
       
       // 这里假设一个存款操作
       public synchronized void deposit(int amount) {
           if (amount > 0) {
               this.balance += amount;
               notifyAll();
           } else {
               System.out.println("Deposit amount cannot be negative.");
               return;
           }
       }
   }
   
   class CustomerAccount {
       private BankAccount bankAccount;
       
       public CustomerAccount(BankAccount bankAccount) {
           this.bankAccount = bankAccount;
       }
       
       // 这里假设一个取款操作
       public synchronized void withdraw(int amount) {
           if (amount > 0 && bankAccount.balance >= amount) {
               bankAccount.balance -= amount;
               notifyAll();
           } else {
               System.out.println("Withdraw amount exceeds balance.");
               return;
           }
       }
   }
   
   class BankService {
       // 这里假设银行有一个存款操作的接口
       public void deposit(BankAccount account, int amount) {
           account.deposit(amount);
       }
       
       // 这里假设银行有一个取款操作的接口
       public void withdraw(BankAccount account, int amount) {
           account.withdraw(amount);
       }
   }
   
   class Customer {
       private BankService bankService;
       
       public Customer(BankService bankService) {
           this.bankService = bankService;
       }
       
       // 这里假设一个存款操作
       public void deposit(int amount) {
           bankService.deposit(new CustomerAccount(new BankAccount())), amount);
       }
       
       // 这里假设一个取款操作
       public void withdraw(int amount) {
           bankService.withdraw(new CustomerAccount(new BankAccount()))), amount);
       }
   }
   
   // 创建银行服务实例
   BankService bankService = new BankService();
   
   // 创建客户账户实例
   BankAccount customerAccount = new BankAccount("1234567890123456"));
   
   // 创建存款操作的客户实例
   Customer customer = new Customer(bankService);
   
   // 存款操作
   customer.deposit(1000); // 会调用银行服务的deposit方法
```
通过这个案例，你可以看到线程安全问题如何出现在并发编程中。同时，也体现了死锁预防的一些策略。