Java多线程编程案例分析：竞态条件、死锁等问题解析

原创超、凢脫俗 2024-09-11 13:06 77阅读 0赞

Java多线程编程是一个复杂且常出现并发问题的领域。下面我们将通过几个实际案例来剖析竞态条件、死锁等问题。

1. **竞态条件**：
   **案例一：共享资源访问**
   ```java
   class Counter {
       int count;
       
       // 两个线程同时调用inc方法
       synchronized void inc() {
           count++;
       }
   }

public class CounterExample {
       public static void main(String[] args) {
           Counter counter = new Counter();
           
           Thread thread1 = new Thread(() -> counter.inc()));
           Thread thread2 = new Thread(() -> counter.inc()));

thread1.start();
           thread2.start();

// 等待所有线程完成
           try {
               thread1.join();
               thread2.join();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

System.out.println("Counter value: " + counter.count);
       }
   }
   ```
   这个案例中，两个线程同时调用`counter.inc()`方法。由于访问共享资源没有同步保护，从而引发了竞态条件。

2. **死锁**：
   **案例二：银行存款转账**
   ```java
   class BankAccount {
       String accountNumber;
       
       // 线程1存款，线程2转账
       synchronized void deposit(int amount) {
           this.balance += amount;
           System.out.println("Deposit successful, account: " + this.accountNumber);
       }
       
       synchronized void transfer(int fromAccount, int toAccount, int amount)) {
           if (amount > 0 && fromAccount != null && toAccount != null) {
               BankAccount fromAccountObj = new BankAccount(fromAccount);
               BankAccount toAccountObj = new BankAccount(toAccount);

this.balance -= fromAccountObj.balance + amount;
               toAccountObj.balance += fromAccountObj.balance + amount;

System.out.println("Transfer successful, accounts: " + fromAccountObj.accountNumber + " -> " + toAccountObj.accountNumber));
           }
       }
   }

public class BankTransactionExample {
       public static void main(String[] args) {
           BankAccount account1 = new BankAccount("12345678901"));
           BankAccount account2 = new BankAccount("98765432102"));

// 线程1存款
           Thread depositThread1 = new Thread(() -> {
               account1.deposit(100);
           }));

// 线程2转账
           Thread transferThread2 = new Thread(() -> {
               account2.transfer(account1.accountNumber, account2.accountNumber, 50));
           }));

depositThread1.start();
           transferThread2.start();

try {
               depositThread1.join();
               transferThread2.join();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

System.out.println("Final account balances: " + account1.balance + " -> " + account2.balance));
       }
   }
   ```
   在这个案例中，线程1存款到账户1，然后线程2试图将50元从账户1转账到账户2。问题在于线程2在尝试转账时可能还没有账户1的最新存款信息。

如果这两个操作没有适当的同步，就可能出现死锁：两个或更多的线程因争夺资源而造成的一种相互等待的现象，若无外力干涉它们都将无法继续执行。

以上就是Java多线程编程中竞态条件和死锁等问题的基本理解和分析。