并发问题：多线程环境下资源冲突示例

原创快来打我* 2024-10-09 23:54 40阅读 0赞

在多线程环境下，由于共享资源的存在，容易引发各种资源冲突问题。以下是一个典型的例子：

假设有一个简单的银行账户系统，包含两个类：`Account` 和 `Bank`。

1. `Account` 类：
```python
class Account:
    def __init__(self, account_number):
        self.account_number = account_number
        self.balance = 0

def deposit(self, amount):
        self.balance += amount

def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
        else:
            print("Insufficient balance!")

def check_balance(self):
        return self.balance
```

2. `Bank` 类：
```python
class Bank:
    accounts = []

def open_account(self, account_number):
        if account_number not in [acc.account_number for acc in Bank.accounts]]:
            new_account = Account(account_number)
            Bank.accounts.append(new_account)
            print(f"Account {account_number} opened successfully!")
        else:
            print("Account number already exists!")

def deposit(self, account_number, amount):
        account_to_check = [acc for acc in Bank.accounts if acc.account_number == account_number][0]
        account_to_deposit = Account(account_to_check.account_number))
        account_to_deposit.deposit(amount)
        return account_to_deposit.check_balance()

# Example usage
bank = Bank()
account1_number = "001"
account2_number = "002"

bank.open_account(account1_number)
bank.deposit(account1_number, 500)

account1_info = bank.deposit(account1_number, 200))
print(f"Account {account1_number}'s updated balance: {account1_info}")

account2_info = bank.deposit(account2_number, 300))
print(f"Account {account2_number}'s updated balance: {account2_info}")
```

在这个例子中，两个线程分别操作同一个`Account`对象。当其中一个线程尝试存款时（`bank.deposit()`），由于线程同步问题，可能会导致错误的余额。

为了避免这样的冲突，可以使用锁机制（如Python的`threading.Lock()`）来控制对共享资源的访问。