Java并发编程：锁竞态与死锁示例

原创雨点打透心脏的1/2处 2024-10-23 20:36 127阅读 0赞

在Java并发编程中，锁的竞态和死锁是两个常见的问题。

1. 锁的竞态：
   竞态（Race Condition）是指多个线程同时访问共享资源，而这些线程的行为看起来像是随机的，导致最终结果不一致的情况。
   
   示例：
   ```java
   class Counter {
       int count;

// 不加锁会引发竞态
       void increment() synchronized(this) {
           count++;
       }
   }

public class Main {
       Counter counter = new Counter();

// 两个线程同时访问counterincrement方法
       Thread thread1 = new Thread(() -> {
           for (int i = 0; i < 10; i++) {
               counter.increment();
           }
       }));

Thread thread2 = new Thread(() -> {
           for (int i = 0; i < 10; i++) {
               counter.increment();
           }
       }));

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

// 等待所有线程执行完毕
       thread1.join();
       thread2.join();

System.out.println("Counter count: " + counter.count);
   }
   ```
   
   结果是不一致的，因为两个线程同时访问了counterincrement方法。

2. 锁的死锁：
   死锁（Deadlock）是指两个或更多的线程互相等待对方释放资源，从而导致它们都无法继续执行下去的一种状态。
   
   示例：
   ```java
   class BankAccount {
       String accountNumber;
       Lock lock = new Lock();

// 没有加锁的deposit方法会引发死锁
       void deposit(int amount) {
           try {
               lock.lock();
               accountNumber += "000" + (amount < 0 ? -amount : amount));
               System.out.println("Deposit successful for account " + accountNumber);
               lock.unlock();
           } catch (Exception e) {
               System.out.println("Error in deposit: " + e.getMessage());
               lock.unlock(); // 把锁解锁，以便其他线程可以访问
           }
       }

// 没有加锁的withdraw方法会引发死锁
       void withdraw(int amount) {
           try {
               lock.lock();
               if (accountNumber.endsWith(amount + "000"))) {
                   accountNumber = accountNumber.substring(0, accountNumber.length() - (amount < 0 ? -amount : amount)) + "000";
                   System.out.println("Withdrawal successful for account " + accountNumber);
                   return true;
               } else {
                   System.out.println("Account number does not match the withdraw amount. Unable to withdraw.");
                   return false;
               }
           } catch (Exception e) {
               System.out.println("Error in withdrawal: " + e.getMessage());
               lock.unlock(); // 把锁解锁，以便其他线程可以访问
           }
       }
   }

public class Main {
       BankAccount account = new BankAccount();

Thread depositThread = new Thread(() -> {
           for (int i = 0; i < 5; i++) {
               account.deposit(100);
               System.out.println("Deposited " + 100 + " for account " + account.accountNumber);
           }
       }));

Thread withdrawThread = new Thread(() -> {
           for (int i = 0; i < 5; i++) {
               account.withdraw(100);
               System.out.println("Withdrawn " + 100 + " for account " + account.accountNumber);
           }
       }));

depositThread.start();
       withdrawThread.start();

// 等待所有线程执行完毕
       depositThread.join();
       withdrawThread.join();

System.out.println("Account details: " + account.accountNumber);
   }
}
```

在这个例子中，`BankAccount`类有两个方法：`deposit`和`withdraw`。这两个方法在没有正确锁住资源的情况下互相调用，导致死锁。

为了避免死锁，通常会采取以下策略：
- 使用`Lock`、`ReentrantLock`等Java并发工具提供的锁定机制。
- 遵循“一个等待者只能等待一个已知的锁持有者释放锁”的原则（也称为“锁顺序”）。
- 考虑到死锁的预防，通常会设置超时时间来避免因资源获取耗时过长而导致的死锁。