Python中死锁的形成示例及死锁情况的防止

#coding=utf-8 
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 transfer(_from,to,amount): 
  if _from.lock.acquire():#锁住自己的账户 
    _from.withdraw(amount) 
    time.sleep(1)#让交易时间变长，2个交易线程时间上重叠，有足够时间来产生死锁 
    print 'wait for lock...' 
    if to.lock.acquire():#锁住对方的账户 
      to.deposit(amount) 
      to.lock.release() 
    _from.lock.release() 
  print 'finish...' 
 
a = Account('a',1000,threading.Lock()) 
b = Account('b',threading.Lock()) 
threading.Thread(target = transfer,args = (a,b,100)).start() 
threading.Thread(target = transfer,args = (b,a,200)).start() 

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

import threading
x_lock = threading.Lock()
y_lock = threading.Lock()

def thread_1():

  while True:
    with acquire(x_lock):
      with acquire(y_lock):
        print('Thread-1')

def thread_2():
  while True:
    with acquire(y_lock):
      with acquire(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()

Exception in thread Thread-1:
Traceback (most recent call last):
 File "/usr/local/lib/python3.3/threading.py",line 639,in _bootstrap_inner
  self.run()
 File "/usr/local/lib/python3.3/threading.py",line 596,in run
  self._target(*self._args,**self._kwargs)
 File "deadlock.py",line 49,in thread_1
  with acquire(y_lock):
 File "/usr/local/lib/python3.3/contextlib.py",line 48,in __enter__
  return next(self.gen)
 File "deadlock.py",line 15,in acquire
  raise RuntimeError("Lock Order Violation")
RuntimeError: Lock Order Violation
>>>

import threading

# The philosopher thread
def philosopher(left,right):
  while True:
    with acquire(left,right):
       print(threading.currentThread(),'eating')

# The chopsticks (represented by locks)
NSTICKS = 5
chopsticks = [threading.Lock() for n in range(NSTICKS)]

# Create all of the philosophers
for n in range(NSTICKS):
  t = threading.Thread(target=philosopher,args=(chopsticks[n],chopsticks[(n+1) % NSTICKS]))
  t.start()