Java多线程挑战：同步问题解析与实例展示

原创梦里梦外; 2024-10-22 18:48 57阅读 0赞

在Java编程中，多线程是一种常见的并行处理方式。然而，在多个线程共享资源时，可能会遇到各种同步问题。以下是对几种常见同步问题的解析及示例：

1. **竞态条件（Race Condition）**：多个线程访问和修改同一份数据，导致结果错误或不可预测。

```java
// 竞态条件示例
class Counter {
    int count;

synchronized void increment() {
        count++;
    }

synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new IllegalArgumentException("Counter is already zero!");
        }
    }
}

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

// 线程1：增加计数器
    Thread thread1 = new Thread(() -> {
        while (counter.count < 5) {
            counter.increment();
            try {
                // 模拟长时间运行
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }));

// 线程2：减少计数器，然后尝试增加计数器
    Thread thread2 = new Thread(() -> {
        counter.decrement();

try {
            // 模拟长时间运行
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

// 尝试增加计数器，如果成功则表示发生了竞态条件
        if (counter.increment() > 0) {
            System.out.println("Race Condition detected!");
        }
    }));

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

thread1.join();
    thread2.join();
}
```

2. **死锁（Deadlock）**：两个或更多的线程相互等待资源，而这些资源又在其他线程中被等待。这样就形成了一个无法继续执行的循环。

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

synchronized void deposit(int amount) {
        balance += amount;
    }

synchronized void withdraw(int amount) throws InsufficientBalanceException {
        if (balance >= amount) {
            balance -= amount;
        } else {
            throw new InsufficientBalanceException("Insufficient balance for withdrawal!");
        }
    }
}

public class DeadlockExample {
    BankAccount account1 = new BankAccount();
    BankAccount account2 = new BankAccount();

// 线程1：向账户1存款
    Thread thread1 = new Thread(() -> {
        try {
            account1.deposit(100);
        } catch (InsufficientBalanceException e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }));

// 线程2：从账户1取款
    Thread thread2 = new Thread(() -> {
        try {
            account1.withdraw(50);
        } catch (InsufficientBalanceException e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }));

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

thread1.join();
    thread2.join();
}
```

在实际编程中，理解并避免这些同步问题是非常重要的。