Java中的并发编程：线程安全和死锁问题实例

原创 Dear 丶 2024-10-09 23:24 69阅读 0赞

在Java中，理解和避免线程安全问题以及死锁问题至关重要。以下是一些实例：

1. **线程安全问题：**当多个线程同时访问共享数据时可能会出现问题。

```java
   // 不安全的线程同步
   class Counter {
       private int count = 0;

public synchronized void increment() {
           count++;
       }

public synchronized int decrement() {
           if (count > 0) {
               count--;
               return count;
           } else {
               throw new IllegalStateException("Counter underflow");
           }
       }

// 真实的线程安全实现
       private final Object lock = new Object();

public void increment() {
           synchronized (lock) {
               count++;
           }
       }

public int decrement() {
           synchronized (lock) {
               if (count > 0) {
                   count--;
                   return count;
               } else {
                   throw new IllegalStateException("Counter underflow");
               }
           }
       }
   ```

2. **死锁问题：**当两个或更多的线程互相等待对方释放资源时就会出现死锁。

```java
   // 死锁示例
   class BankAccount {
       private String accountNumber;
       private int balance;

public BankAccount(String accountNumber, int balance) {
           this.accountNumber = accountNumber;
           this.balance = balance;
       }

// 线程1：存入50
       public synchronized void deposit(int amount) {
           if (amount > 0 && balance + amount <= Integer.MAX_VALUE) {
               balance += amount;
               System.out.println("Deposit successful. New balance: " + balance);
           } else {
               System.out.println("Deposit failed. Amount exceeds limit or balance is already maximum.");
           }
       }

// 线程2：取款50
       public synchronized void withdraw(int amount) {
           if (amount > 0 && balance - amount >= Integer.MIN_VALUE) {
               balance -= amount;
               System.out.println("Withdrawal successful. New balance: " + balance);
           } else {
               System.out.println("Withdrawal failed. Amount exceeds limit or balance is already minimum.");
           }
       }
   }

class BankCustomerThread extends Thread {
       private BankAccount bankAccount;

public BankCustomerThread(BankAccount bankAccount) {
           this.bankAccount = bankAccount;
       }

@Override
       public void run() {
           try {
               System.out.println("Bank customer thread started");

// 线程1：存入50
               bankAccount.deposit(50);
               Thread.sleep(2000); // 暂停2秒，模拟操作时间

// 线程2：取款50
               bankAccount.withdraw(50);
               System.out.println("Bank customer thread completed");

} catch (InterruptedException | Exception e) {
               System.out.println("Bank customer thread interrupted or encountered error: " + e.getMessage());
               e.printStackTrace();
           }
       }
   }

public class BankSystemExample {
       public static void main(String[] args) throws InterruptedException {
           // 创建银行账户对象
           BankAccount bankAccount = new BankAccount("123456789", 0));

// 创建存款线程并启动
           BankCustomerThread depositThread = new BankCustomerThread(bankAccount);
           depositThread.start();

// 暂停2秒，模拟操作时间
           Thread.sleep(2000);

// 创建取款线程并启动
           BankCustomerThread withdrawThread = new BankCustomerThread(bankAccount);
           withdrawThread.start();
       }
   }
```

在这个例子中，银行账户（BankAccount）是线程安全的。但是，两个线程分别执行存款和取款操作时可能会出现问题，因为它们共享同一资源。

解决死锁的方法包括避免互斥条件、避免循环等待条件以及使用超时机制等。