Python多线程之死锁

# coding=utf-8
import time
import threading


class Account:
    def __init__(self, _id, balance):
        self.id = _id
        self.balance = balance
    def withdraw(self, amount):
        self.balance -= amount
    def deposit(self, amount):
        self.balance += amount


def transfera_b(_from, to, amount):
    lock_a.acquire()  # 锁住自己的账户
    time.sleep(1)  # 让交易时间变长，2个交易线程时间上重叠，有足够时间来产生死锁
    _from.withdraw(amount)
    print(‘wait for lock_b‘)
    lock_b.acquire()  # 锁住对方的账户
    to.deposit(amount)
    lock_b.release()
    lock_a.release()


def transferb_a(_from, to, amount):
    lock_b.acquire()  # 锁住自己的账户
    time.sleep(1)  # 让交易时间变长，2个交易线程时间上重叠，有足够时间来产生死锁
    _from.withdraw(amount)
    print(‘wait for lock_a‘)
    lock_a.acquire()  # 锁住对方的账户
    to.deposit(amount)
    lock_a.release()
    lock_b.release()

lock_a = threading.Lock()
lock_b = threading.Lock()
a = Account(‘a‘, 1000)
b = Account(‘b‘, 1000)
#a往b转账100
t1 = threading.Thread(target=transfera_b, args=(a, b, 100))
t1.start()
#b往a转账200
t2 = threading.Thread(target=transferb_a, args=(b, a, 200))
t2.start()
t1.join()
t2.join()
print("a的账户余额：",a.balance)
print("b的账户余额：",b.balance)

# coding=utf-8
import time
import threading

class Account:
    def __init__(self, _id, balance):
        self.id = _id
        self.balance = balance
        self.lock = threading.Lock()
    def withdraw(self, amount):
        self.balance -= amount
    def deposit(self, amount):
        self.balance += amount

def transfer(_from,to, amount):
    _from.lock.acquire()  # 锁住自己的账户
    time.sleep(1)  # 让交易时间变长，2个交易线程时间上重叠，有足够时间来产生死锁
    _from.withdraw(amount)
    print(‘wait for lock‘)
    to.lock.acquire()  # 锁住对方的账户
    to.deposit(amount)
    to.lock.release()
    _from.lock.release()

a = Account(‘a‘, 1000)
b = Account(‘b‘, 1000)
#a往b转账100
t1 = threading.Thread(target=transfer, args=(a, b, 100))
t1.start()
#b往a转账200
t2 = threading.Thread(target=transfer, args=(b, a, 200))
t2.start()
t1.join()
t2.join()
print("a的账户余额：",a.balance)
print("b的账户余额：",b.balance)

import threading
from contextlib import contextmanager
 
# Thread-local state to stored information on locks already acquired
_local = threading.local()
 
@contextmanager
def acquire(*locks):
  # Sort locks by object identifier
  locks = sorted(locks, key=lambda x: id(x))
 
  # Make sure lock order of previously acquired locks is not violated
  acquired = getattr(_local,‘acquired‘,[])
  if acquired and max(id(lock) for lock in acquired) >= id(locks[0]):
    raise RuntimeError(‘Lock Order Violation‘)
 
  # Acquire all of the locks
  acquired.extend(locks)
  _local.acquired = acquired
 
  try:
    for lock in locks:
      lock.acquire()
    yield
  finally:
    # Release locks in reverse order of acquisition
    for lock in reversed(locks):
      lock.release()
    del acquired[-len(locks):]

import threading
x_lock = threading.Lock()
y_lock = threading.Lock()
 
def thread_1():
  while True:
    with acquire(x_lock, y_lock):
      print(‘Thread-1‘)
 
def thread_2():
  while True:
    with acquire(y_lock, x_lock):
      print(‘Thread-2‘)
 
t1 = threading.Thread(target=thread_1)
t1.daemon = True
t1.start()
 
t2 = threading.Thread(target=thread_2)
t2.daemon = True
t2.start()

解决协作对象之间发生的死锁：需要使用开放调用，即避免在持有锁的情况下调用外部的方法，就是尽量将锁的范围缩小，将同步代码块仅用于保护那些设计共享状态的操作。