Python线程的同步互斥与死锁的介绍_F11 - 专业站长和开发者的学习网站

分享到

Python线程的同步互斥与死锁的介绍

python 来源：互联网搜集作者：秩名发布时间：2020-03-22 20:47:14 人浏览

摘要

线程间通信方法 1. 通信方法线程间使用全局变量进行通信 2. 共享资源争夺共享资源：多个进程或者线程都可以操作的资源称为共享资源。对共享资源的操作代码段称为临界区。影响：对共享资源的无序操作可能会带来数据的混乱，或者操作错误。此时往往需要同

线程间通信方法

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())

您可能感兴趣的文章 :

原文链接 : https://blog.csdn.net/chiaotien/article/details/104511702

Tag : python(762)死锁(3)

Python Django教程之实现新闻应用程序

Django是一个用Python编写的高级框架，它允许我们创建服务器端Web应用程序。在本文中，我们将了解如何使用Django创建新闻应用程序。我们将
书写Python代码的一种更优雅方式(推荐!)

一些比较熟悉pandas的读者朋友应该经常会使用query()、eval()、pipe()、assign()等pandas的常用方法，书写可读性很高的「链式」数据分析处理代码
Python灰度变换中伽马变换分析实现

1. 介绍伽马变换主要目的是对比度拉伸，将图像灰度较低的部分进行修正伽马变换针对的是对单个像素点的变换，也就是点对点的映射形
使用OpenCV实现迷宫解密的全过程

一、你能自己走出迷宫吗？如下图所示，可以看到是一张较为复杂的迷宫图，相信也有人尝试过自己一点一点的找出口，但我们肉眼来解谜
Python中的数据精度问题的介绍

一、python运算时精度问题 1.运行时精度问题在Python中（其他语言中也存在这个问题，这是计算机采用二进制导致的），有时候由于二进制和
Python随机值生成的常用方法

一、随机整数 1.包含上下限：[a, b] 1 2 3 4 import random #1、随机整数：包含上下限：[a, b] for i in range(10): print(random.randint(0,5),end= | ) 查看运行结
Python字典高级用法深入分析讲解

一、 collections 中 defaultdict 的使用 1.字典的键映射多个值将下面的列表转成字典 l = [(a,2),(b,3),(a,1),(b,4),(a,3),(a,1),(b,3)] 一个字典就是一个键对
Python浅析多态与鸭子类型使用实例

什么多态：同一事物有多种形态为何要有多态=》多态会带来什么样的特性，多态性多态性指的是可以在不考虑对象具体类型的情况下而直
Python字典高级用法深入分析介绍

一、 collections 中 defaultdict 的使用 1.字典的键映射多个值将下面的列表转成字典 l = [(a,2),(b,3),(a,1),(b,4),(a,3),(a,1),(b,3)] 一个字典就是一个键对
Python淘宝或京东等秒杀抢购脚本实现(秒杀脚本

我们的目标是秒杀淘宝或京东等的订单，这里面有几个关键点，首先需要登录淘宝或京东，其次你需要准备好订单，最后要在指定时间快速