Python并发编程—同步互斥

同步互斥

线程间通信方法

1.通信方法：线程间使用全局变量进行通信

2.共享资源争夺

 

• 共享资源：多个进程或者线程都可以操作的资源称为共享资源。对共享资源的操作代码段称为临界区。
• 影响 ： 对共享资源的无序操作可能会带来数据的混乱，或者操作错误。此时往往需要同步互斥机制协调操作顺序。

 

3.同步互斥机制

同步 ： 同步是一种协作关系，为完成操作，多进程或者线程间形成一种协调，按照必要的步骤有序执行操作。

互斥 ： 互斥是一种制约关系，当一个进程或者线程占有资源时会进行加锁处理，此时其他进程线程就无法操作该资源，直到解锁后才能操作。

线程同步互斥方法

线程Event

from threading import Event

e = Event() 创建线程event对象

e.wait([timeout]) 阻塞等待e被set

e.set() 设置e，使wait结束阻塞

e.clear() 使e回到未被设置状态

e.is_set() 查看当前e是否被设置

from threading import Thread,Event

s = None  # 用于通信
e = Event() # 创建event对象

def 杨子荣():
  print("杨子荣前来拜山头")
  global s
  s = "天王盖地虎"
  e.set()  # 对e设置

t = Thread(target=杨子荣)
t.start()

print("说对口令就是自己人")
e.wait()  # 阻塞等待口令说出
if s == '天王盖地虎':
  print("宝塔镇河妖")
  print("确认过眼神,你是对的人")
else:
  print("打死他...")

t.join()

# 说对口令就是自己人
# 杨子荣前来拜山头
# 宝塔镇河妖
# 确认过眼神,你是对的人

线程锁 Lock

from threading import Lock

lock = Lock() 创建锁对象

lock.acquire() 上锁 如果lock已经上锁再调用会阻塞

lock.release() 解锁

with lock: 上锁

...

...

with代码块结束自动解锁

from threading import Thread,Lock

a = b = 0
lock = Lock() # 定义锁

def value():
  while True:
    lock.acquire()  # 上锁
    if a != b:
      print("a = %d,b = %d"%(a,b))
    lock.release() # 解锁

t = Thread(target = value)
t.start()

while True:
  with lock:
    a += 1
    b += 1

t.join()

死锁及其处理

1.定义：死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。

2.死锁产生条件

• 死锁发生的必要条件
• 互斥条件：指线程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
• 请求和保持条件：指线程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求线程阻塞，但又对自己已获得的其它资源保持不放。
• 不剥夺条件：指线程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放,通常CPU内存资源是可以被系统强行调配剥夺的。
• 环路等待条件：指在发生死锁时，必然存在一个线程——资源的环形链，即进程集合{T0，T1，T2，···，Tn}中的T0正在等待一个T1占用的资源；T1正在等待T2占用的资源，……，Tn正在等待已被T0占用的资源。

3.死锁的产生原因

简单来说造成死锁的原因可以概括成三句话：

• 当前线程拥有其他线程需要的资源
• 当前线程等待其他线程已拥有的资源
• 都不放弃自己拥有的资源

4.如何避免死锁

死锁是我们非常不愿意看到的一种现象，我们要尽可能避免死锁的情况发生。通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。预防死锁是一种较易实现的方法。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率。

import time
import threading

# 交易类
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

# 创建账户
Tom = Account('Tom',5000,threading.Lock())
Alex = Account('Alex',8000,threading.Lock())

# 转账函数
def  transfer(from_,to,amount):
  if from_.lock.acquire():  #锁自己账户
    from_.withdraw(amount) # 自己账户减少
    time.sleep(0.5)
    if to.lock.acquire(): # 对方账户上锁
      to.deposit(amount)
      to.lock.release()  # 对方账户解锁
    from_.lock.release() # 自己账户解锁
  print("%s 给 %s转账完成"%(from_.id,to.id))

t1 = threading.Thread(target = transfer,
                       args=(Tom,Alex,2000))
t2 = threading.Thread(target = transfer,
                       args=(Alex,Tom,2000))
t1.start()
t2.start()
t1.join()
t2.join()