1. 互斥锁简介

在多线程编程中，当多个线程需要访问共享资源时，可能会发生资源竞争问题。互斥锁（Mutex Lock）是一种同步原语，用于确保在任何时刻只有一个线程可以访问特定的资源或代码段。

Python的threading模块提供了Lock类来实现互斥锁机制，是解决多线程资源竞争问题的核心工具。

2. 资源竞争问题

当多个线程同时访问和修改共享资源时，由于线程调度的不确定性，可能导致数据不一致或程序错误。

import threading

# 共享资源
counter = 0

def increment():
    global counter
    for _ in range(100000):
        counter += 1

# 创建多个线程
threads = []
for i in range(5):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

# 等待所有线程完成
for t in threads:
    t.join()

print(f"Final counter value: {counter}")  # 预期500000，实际结果可能小于这个值

在这个例子中，由于多个线程同时修改counter变量，导致最终结果小于预期值。这是因为counter += 1操作不是原子操作，它实际上包含读取、修改和写入三个步骤。

3. 互斥锁解决方案

使用互斥锁可以解决上述资源竞争问题，确保共享资源的修改是线程安全的。

更推荐使用上下文管理器语法，可以自动管理锁的获取和释放：

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:  # 自动获取和释放锁
            counter += 1

threads = []
for i in range(5):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"Final counter value: {counter}")  # 现在总是500000

4. 银行账户案例

下面是一个更实际的例子，展示如何使用互斥锁保护银行账户操作：

import threading
import time
import random

class BankAccount:
    def __init__(self, initial_balance=0):
        self.balance = initial_balance
        self.lock = threading.Lock()
    
    def deposit(self, amount):
        with self.lock:
            print(f"存款: +{amount}")
            self.balance += amount
            print(f"新余额: {self.balance}")
    
    def withdraw(self, amount):
        with self.lock:
            if self.balance >= amount:
                print(f"取款: -{amount}")
                self.balance -= amount
                print(f"新余额: {self.balance}")
                return True
            else:
                print(f"取款失败: 余额不足")
                return False

def account_activity(account, operations=10):
    for _ in range(operations):
        action = random.choice(['deposit', 'withdraw'])
        amount = random.randint(10, 100)
        if action == 'deposit':
            account.deposit(amount)
        else:
            account.withdraw(amount)
        time.sleep(0.1)

# 创建账户
account = BankAccount(200)

# 创建多个线程操作同一个账户
threads = []
for i in range(3):
    t = threading.Thread(target=account_activity, args=(account, 5))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"最终余额: {account.balance}")

5. 互斥锁最佳实践

6. 总结

在多线程编程中，互斥锁是解决资源竞争问题的关键工具。通过本教程，我们学习了：