Python多线程同步互斥机制与死锁原理详解
本文深入解析Python多线程编程中的同步与互斥机制。通过Event对象实现线程协作，利用Lock锁保护临界区资源，并详细阐述死锁的四个必要条件。文章结合代码示例说明如何避免死锁，帮助开发者构建稳定高效的多线程应用。
线程间通信与共享资源管理
线程间通信方法
1. 通信方法
在多线程环境中，线程间可以使用全局变量进行数据通信。这种方式简单直接，但需要注意并发访问时的数据一致性问题。
2. 共享资源争夺
共享资源是指多个进程或线程均可访问和操作的资源。对这类资源进行操作的代码段被称为临界区。
若对共享资源的访问缺乏有序控制，可能导致数据混乱或操作错误。因此，通常需要引入同步互斥机制来协调各线程的操作顺序，确保数据一致性。
同步与互斥机制解析
3. 同步互斥机制
同步是一种协作关系，旨在完成特定操作。多进程或线程间需形成协调，按必要的步骤有序执行。例如，两个或多个进程或线程在运行过程中协同步调，按照预定的先后次序执行。典型场景如A任务的执行依赖于B任务产生的数据。
互斥是一种制约关系。当一个进程或线程占用资源时，会进行加锁处理，此时其他进程或线程无法操作该资源，直到解锁后才能继续。其核心原则是：一个公共资源在同一时刻只能被一个进程或线程使用，多个进程或线程不能同时访问同一公共资源。
线程同步互斥方法
线程同步与锁的实现示例
线程Event同步
from threading import Event
e = Event() 创建线程event对象
e.wait([timeout]) 阻塞等待e被set
e.set() 设置e，使wait结束阻塞
e.clear() 使e回到未被设置状态
e.is_set() 查看当前e是否被设置
示例：
import time
import threading
event = threading.Event()
# 红绿灯
def lighter():
count = 0
event.set() # 刚进来的时候是绿灯
while True:
if 4 < count < 10:
event.clear() # 清除设置，阻塞等待
print("[信号灯]：红，不能通行", count)
elif count >= 10: # 添加设置，继续执行
event.set()
count = 0
else:
event.set() # 添加设置，继续执行
print("[信号灯]：绿灯，可以通行", count)
time.sleep(1)
count += 1
# 汽车
def car(name):
while True:
if event.is_set():
print("{0}: 绿灯 , 走起...".format(name))
time.sleep(1)
else:
print("{0}: 红灯 , 停车...".format(name))
event.wait()
print("{0}: 绿灯亮了 , 继续前进...".format(name))
light = threading.Thread(target=lighter, )
light.start()
car1 = threading.Thread(target=car, args=("小跑",))
car1.start()线程锁 Lock
from threading import Lock
lock = Lock() #创建锁对象
lock.acquire() #上锁 如果lock已经上锁再调用会阻塞
lock.release() #解锁使用 with lock: 语句可实现上锁操作。
当with代码块执行结束时，锁会自动释放（自动解锁）。
示例：
from threading import Thread, Lock
from time import sleep
a = b = 0
lock = Lock()
# 子线程输出a b
def value():
while True:
lock.acquire() # 上锁
if a != b:
print("a = %d,b = %d" % (a, b))
lock.release() # 解锁
t = Thread(target=value)
t.start()
# 主线程加锁更改a b时候，子线程处理a b 时也要进行加锁，重复加锁就会阻塞等待主线程处理结束
# 同理主进程再次更改a b 时等 子进程结束才可以
while True:
with lock: # 自动上/解锁
a += 1
b += 1
t.join死锁原理、条件及避免策略
死锁及其处理
1. 定义
死锁是指两个或两个以上的线程在执行过程中，因竞争资源或彼此通信而造成的阻塞现象。若无外力作用，这些线程将无法继续推进，此时称系统处于死锁状态或产生了死锁。
2. 死锁产生条件
【互斥条件】：指线程对所分配到的资源进行排他性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求该资源，则请求者只能等待，直至占有资源的进程使用完毕并释放资源。
【请求和保持条件】：指线程已经保持至少一个资源，但又提出了新的资源请求。若该资源已被其它进程占有，此时请求线程阻塞，但它对自己已获得的其它资源保持不放。
【不剥夺条件】：指线程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。注意，通常CPU和内存资源是可以被系统强行调配或剥夺的，但其他资源往往遵循此条件。
【环路等待条件】：指在发生死锁时，必然存在一个线程——资源的环形链。即进程集合{T0，T1，T2，···，Tn}中的T0正在等待一个T1占用的资源；T1正在等待T2占用的资源，……，Tn正在等待已被T0占用的资源。
简单来说，造成死锁的原因可以概括成三句话：
【1】当前线程拥有其他线程需要的资源
【2】当前线程等待其他线程已拥有的资源
【3】都不放弃自己拥有的资源
例如，T1拥有R1，T2拥有R2。T1请求使用R2，T2请求使用R1，但是T1和T2都不愿释放R1和R2，互相一直等待下去，从而造成死锁。
3. 如何避免死锁
死锁是我们非常不愿意看到的一种现象，我们要尽可能避免死锁的情况发生。通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。预防死锁是一种较易实现的方法。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率降低。
from threading import Lock, Thread
# 交易类
class Account:
def __init__(self, _id, balance, lock):
self.id = _id
self.balance = balance
self.lock = lock # 各自账户锁
# 取钱
def withdraw(self, amount):
self.balance -= amount
# 存钱
def deposit(self, amount):
self.balance += amount
# 查看账户
def get_balance(self):
return self.balance
# 转账
def transfer(from_, to, amount):
if from_.lock.acquire(): # 锁住自己的账户
from_.withdraw(amount) # 自己账户减少
if to.lock.acquire(): # 锁住对方账户
to.deposit(amount) # 对方账户增加
to.lock.release() # 解锁对方账户
from_.lock.release() # 自己账户解锁
print("转账完成")
Abby = Account("Abby", 5000, Lock())
Balen = Account("Balen", 3000, Lock())
t = Thread(target=transfer, args=(Abby, Balen, 1000))
t2 = Thread(target=transfer, args=(Balen, Abby, 500))
t.start()
t2.start()
t.join()
t2.join()
print("Abby:", Abby.get_balance())
print("Balen:", Balen.get_balance())到此这篇关于浅谈Python线程的同步互斥与死锁的文章就介绍到这了,更多相关Python线程同步互斥与死锁内容请搜索本站以前的文章或继续浏览下面的相关文章希望大家以后多多支持本站！
免责声明：本文内容仅供参考，不代表本站观点。转载或引用请注明出处。
