Python多进程同步全解析:从竞争条件到锁、信号量的实战应用

1. 进程同步的必要性

在多进程编程中,当多个进程需要访问共享资源时,会出现竞争条件问题。例如火车票售卖系统中,如果多个售票窗口同时读取和修改剩余票数,可能导致数据不一致。

1.1 竞争条件示例

from multiprocessing import Process, Value

def sell_tickets(tickets):
    for _ in range(1000):
        tickets.value -= 1  # 非原子操作

if __name__ == '__main__':
    tickets = Value('i', 10000)
    processes = [Process(target=sell_tickets, args=(tickets,)) 
                for _ in range(10)]
    
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    
    print(f"剩余票数: {tickets.value}")  # 结果不确定,可能大于0

在多进程环境下,多个进程可以同时执行。像代码里的tickets.value -= 1操作,实际上并非原子操作。它包含读取tickets.value的值、对该值减 1、再把新值写回tickets.value这几个步骤。当多个进程同时执行这一操作时,就可能出现数据不一致的状况。比如,两个进程同时读取到剩余票数为 100,各自减 1 后都写回 99,而实际上应该是 98。

2. 锁(Lock)机制

锁机制可以保证同一时间只有一个进程能够访问共享资源。当一个进程获取到锁之后,其他进程就必须等待该进程释放锁,才能继续访问共享资源。这样就能避免多个进程同时修改共享资源,从而解决竞争条件问题。

2.1 基础锁使用

from multiprocessing import Process, Lock, Value

def sell_tickets(tickets, lock):
    for _ in range(1000):
        lock.acquire()
        tickets.value -= 1
        lock.release()

if __name__ == '__main__':
    tickets = Value('i', 10000)
    lock = Lock()
    processes = [Process(target=sell_tickets, args=(tickets, lock)) 
                for _ in range(10)]
    
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    
    print(f"剩余票数: {tickets.value}")

在上述代码中,lock.acquire()用于获取锁,一旦某个进程获取到锁,其他进程就只能等待。tickets.value -= 1是对共享资源的修改操作,由于有锁的保护,同一时间只有一个进程能执行这一操作。lock.release()用于释放锁,释放后其他进程就可以竞争获取锁。

2.2 上下文管理器简化

from multiprocessing import Process, Lock, Value

def sell_tickets(tickets, lock):
    for _ in range(1000):
        with lock:  # 自动获取和释放锁
            tickets.value -= 1

if __name__ == '__main__':
    tickets = Value('i', 10000)
    lock = Lock()
    processes = [Process(target=sell_tickets, args=(tickets, lock)) 
                for _ in range(10)]
    
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    
    print(f"剩余票数: {tickets.value}")

使用with lock语句,Python 会自动帮我们获取和释放锁。进入with语句块时,会自动调用lock.acquire()获取锁;离开with语句块时,会自动调用lock.release()释放锁。这样可以让代码更加简洁,也能避免忘记释放锁的问题。

2.3 银行转账案例

原始问题代码(存在竞争条件)
from multiprocessing import Process, Value
import time

def transfer(balance, amount):
    # 没有锁保护的转账操作
    current = balance.value
    time.sleep(0.01)  # 模拟处理延迟
    balance.value = current + amount  # 非原子操作

if __name__ == '__main__':
    balance = Value('i', 100)  # 初始余额100
    
    # 创建100个存款和100个取款进程
    processes = []
    for _ in range(100):
        p_deposit = Process(target=transfer, args=(balance, 1))  # 存1元
        p_withdraw = Process(target=transfer, args=(balance, -1)) # 取1元
        processes.extend([p_deposit, p_withdraw])
    
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    
    print(f"最终余额: {balance.value}")  # 预期应该是100,但实际结果不确定

问题分析

  1. 多个进程同时读取和修改balance.value会导致竞争条件

  2. balance.value = current + amount不是原子操作

  3. 由于time.sleep放大了竞争窗口,问题更容易显现

  4. 最终余额可能不等于初始值100,说明出现了数据不一致

改进后的解决方案(使用Lock)
from multiprocessing import Process, Value, Lock
import time

def transfer(balance, lock, amount):
    with lock:  # 使用上下文管理器自动获取和释放锁
        current = balance.value
        time.sleep(0.01)  # 模拟处理延迟
        balance.value = current + amount

if __name__ == '__main__':
    balance = Value('i', 100)  # 初始余额100
    lock = Lock()  # 创建锁对象
    
    processes = []
    for _ in range(100):
        p_deposit = Process(target=transfer, args=(balance, lock, 1))  # 存1元
        p_withdraw = Process(target=transfer, args=(balance, lock, -1)) # 取1元
        processes.extend([p_deposit, p_withdraw])
    
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    
    print(f"最终余额: {balance.value}")  # 现在总能正确输出100

改进点说明

  1. 引入Lock对象保证对共享变量的互斥访问

  2. 使用with lock:上下文管理器简化锁的获取和释放

  3. 确保读取-修改-写入操作成为原子操作

  4. 即使有延迟,也能保证数据一致性

执行结果对比
版本运行次数可能结果说明
原始版本10次90-110之间随机因竞争条件结果不确定
改进版本10次每次都是100保证数据一致性
可视化问题发生过程
时间线       进程A(存款)               进程B(取款)              余额值
--------------------------------------------------------------------
 t1      读取balance=100
 t2                          读取balance=100
 t3      计算100+1=101
 t4                          计算100-1=99
 t5      写入101
 t6                          写入99

由于没有同步机制,后写入的操作会覆盖前一个操作,导致存款操作"丢失"。

更优实践建议

对于这种计数器场景,可以使用Value的原子操作:

from multiprocessing import Value

balance = Value('i', 100)
balance.value += 1  # 非原子操作(不安全)
balance.get_lock().acquire()
balance.value += 1  # 原子操作(安全)
balance.get_lock().release()

# 或者使用with语句
with balance.get_lock():
    balance.value += 1

这样可以直接使用共享变量自带的锁,代码更简洁。

3. 信号量(Semaphore)

信号量是更高级的同步原语,允许指定数量的进程同时访问资源。

3.1 基础信号量

from multiprocessing import Semaphore

s = Semaphore(3)  # 允许3个进程同时访问

s.acquire()
print("进程1进入")
s.acquire()
print("进程2进入")
s.acquire()
print("进程3进入")
# 此时第4个进程会被阻塞

3.2 教室钥匙案例

from multiprocessing import Process, Semaphore
import time
import random

def student(id, sem):
    with sem:
        print(f"学生{id}进入教室")
        time.sleep(random.uniform(1, 3))
        print(f"学生{id}离开教室")

if __name__ == '__main__':
    sem = Semaphore(5)  # 5把钥匙
    students = [Process(target=student, args=(i, sem)) 
               for i in range(20)]
    
    for s in students:
        s.start()
    for s in students:
        s.join()

4. 事件(Event)机制

事件用于进程间的简单通信,一个进程发出"事件已发生"信号,其他进程等待该事件。

4.1 事件基础

from multiprocessing import Event

e = Event()
print(e.is_set())  # False

e.set()
print(e.is_set())  # True
e.wait()  # 立即通过

e.clear()
e.wait()  # 阻塞直到set()被调用

4.2 红绿灯控制案例

from multiprocessing import Process, Event
import time

def traffic_light(e):
    while True:
        print("\033[32m绿灯亮\033[0m" if e.is_set() else "\033[31m红灯亮\033[0m")
        time.sleep(2)
        e.set() if not e.is_set() else e.clear()

def car(e, car_id):
    e.wait()
    print(f"汽车{car_id}通过路口")

if __name__ == '__main__':
    e = Event()
    light = Process(target=traffic_light, args=(e,))
    light.daemon = True  # 守护进程,主进程结束自动退出
    light.start()
    
    for i in range(10):
        time.sleep(0.5)
        Process(target=car, args=(e, i)).start()

5. 综合案例:火车票售卖系统

5.1 共享内存实现

from multiprocessing import Process, Value, Lock
import time

class TicketSeller(Process):
    def __init__(self, tickets, lock, name):
        super().__init__()
        self.tickets = tickets
        self.lock = lock
        self.name = name
        
    def run(self):
        while True:
            with self.lock:
                if self.tickets.value <= 0:
                    break
                time.sleep(0.1)  # 模拟处理时间
                print(f"{self.name}售出票号{self.tickets.value}")
                self.tickets.value -= 1

if __name__ == '__main__':
    tickets = Value('i', 100)
    lock = Lock()
    
    sellers = [TicketSeller(tickets, lock, f"窗口{i}") 
              for i in range(1, 4)]
    
    for s in sellers:
        s.start()
    for s in sellers:
        s.join()
    
    print("所有票已售完")

5.2 文件共享实现

from multiprocessing import Process, Lock
import time

def sell_tickets(lock, window):
    while True:
        with lock:
            with open("tickets.txt", "r+") as f:
                tickets = int(f.read())
                if tickets <= 0:
                    break
                time.sleep(0.1)
                print(f"{window}售出票号{tickets}")
                f.seek(0)
                f.write(str(tickets-1))

if __name__ == '__main__':
    lock = Lock()
    
    # 初始化票数
    with open("tickets.txt", "w") as f:
        f.write("100")
    
    processes = [Process(target=sell_tickets, args=(lock, f"窗口{i}"))
                for i in range(1, 4)]
    
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    
    print("所有票已售完")

6. 同步机制选择指南

机制适用场景优点缺点
Lock互斥访问共享资源简单直接可能引起死锁
Semaphore限制资源访问数量灵活控制并发度比锁复杂
Event进程间简单通知轻量级通知机制不传递数据

7. 常见问题解答

Q1: 锁和信号量的区别是什么?

  • 锁是二元信号量(0/1),信号量可以设置多个许可

  • 锁用于互斥访问,信号量用于控制资源访问数量

Q2: 如何避免死锁?

  • 按固定顺序获取多个锁

  • 使用超时机制

  • 避免嵌套锁

Q3: 文件共享和共享内存哪个更好?

  • 共享内存更快但更复杂

  • 文件共享更简单但性能较低

  • 根据场景选择合适方案

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值