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,但实际结果不确定
问题分析:
-
多个进程同时读取和修改
balance.value
会导致竞争条件 -
balance.value = current + amount
不是原子操作 -
由于
time.sleep
放大了竞争窗口,问题更容易显现 -
最终余额可能不等于初始值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
改进点说明:
-
引入
Lock
对象保证对共享变量的互斥访问 -
使用
with lock:
上下文管理器简化锁的获取和释放 -
确保
读取-修改-写入
操作成为原子操作 -
即使有延迟,也能保证数据一致性
执行结果对比
版本 | 运行次数 | 可能结果 | 说明 |
---|---|---|---|
原始版本 | 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: 文件共享和共享内存哪个更好?
-
共享内存更快但更复杂
-
文件共享更简单但性能较低
-
根据场景选择合适方案