python自学成才之路 死锁的解决方案
以下内容是我阅读cookbook上的死锁解决方案的读后感，感觉上面的思想很不错，想给大家分享下，我在其中加了一些我自己的理解，感兴趣的话可以阅读原文： https://python3-cookbook.readthedocs.io/zh_CN/latest/c12/p05_locking_with_deadlock_avoidance.html#id3
关于死锁有一个经典的问题，”哲学家就餐问题“，题目是这样的：五位哲学家围坐在一张桌子前，每个人 面前有一碗饭和一只筷子。在这里每个哲学家可以看做是一个独立的线程，而每只筷子可以看做是一个锁。每个哲学家可以处在静坐、 思考、吃饭三种状态中的一个。需要注意的是，每个哲学家吃饭是需要两只筷子的，这样问题就来了：如果每个哲学家都拿起自己左边的筷子， 那么他们五个都只能拿着一只筷子坐在那儿，直到饿死。此时他们就进入了死锁状态。
解决死锁最好的方法是避免死锁。不要等问题发生了再去解决，而是在源头上避免发生问题。出现死锁的充要条件是形成一个环，所以如果在并发开发的时候，不要让环形成，死锁产生的条件满足不了，是不是就避免了死锁。
解决方案： 主要目的是避免形成环，可以这样做，给每个锁分配一个唯一的id，然后只允许按照升序的规则来使用多个锁。举个例子：有十个锁L1~L10，三个线程t1，t2，t3。t1需要L1，L2，L5，L6四个锁，t2需要L3，L5，L6，L9，四个锁，t3需要L1，L4，L7，L8，L9，L10五个锁。这三个线程每次申请锁的时候都按照自己的需要顺序去申请锁，由于这些锁的申请过程都是按照顺序来的，即使部分锁是多个线程需要的，但是顶多会出现等待的情况，不会出现死锁。如何让锁的获取是按照顺序来？可以通过上下文管理器来实现，对于上下文管理器可以看下我之前的文章。
import threading
from contextlib import contextmanager
# 定义一个线程本地对象
_local = threading.local()
@contextmanager
def acquire(*locks):
# 该线程需要获取的锁按照id做一个排序
locks = sorted(locks, key=lambda x: id(x))
# 确保这些锁获取是有序的，如果出现无序则抛出异常
acquired = getattr(_local,'acquired',[])
if acquired and max(id(lock) for lock in acquired) >= id(locks[0]):
raise RuntimeError('Lock Order Violation')
# 将获取到的锁放到线程本地对象上
acquired.extend(locks)
_local.acquired = acquired
try:
for lock in locks:
lock.acquire()
yield
finally:
# 所有的锁使用完之后，按照倒序的方式进行释放，也就是从大到小的顺序进行释放
for lock in reversed(locks):
lock.release()
del acquired[-len(locks):]这段代码从语法的角度来看可能有两个地方不理解，一个是@contextmanager这个注解，这是上下文管理器的注解，作用和with是一样的，关于这一段可以查看我之前的文章。
第二个不好理解的地方是acquired = getattr(_local,‘acquired’,[])这段代码，这段代码的意思是获取线程本地对象的acquired这个属性，如果没有这个属性则创建一个这样的属性，并赋予初始值[]。
怎么去使用这个上下文管理器呢？看下面这个案例，有三个线程，每个线程都需要申请多个锁，他们申请的锁有些是三个线程都需要的有些是每个线程各自独有的，这些锁都通个acquire这个上下文管理器来获取。
import time
a_lock = threading.Lock()
b_lock = threading.Lock()
c_lock = threading.Lock()
d_lock = threading.Lock()
e_lock = threading.Lock()
f_lock = threading.Lock()
g_lock = threading.Lock()
def thread_1():
while True:
with acquire(a_lock, b_lock, e_lock):
print('Thread-1')
def thread_2():
while True:
with acquire(c_lock, d_lock, e_lock, f_lock):
print('Thread-2')
def thread_3():
while True:
with acquire(a_lock, b_lock, e_lock, f_lock, g_lock):
print('Thread-3')
t1 = threading.Thread(target=thread_1)
t1.daemon = True
t1.start()
t2 = threading.Thread(target=thread_2)
t2.daemon = True
t2.start()
t3 = threading.Thread(target=thread_3)
t3.daemon = True
t3.start()
time.sleep(200)这一段代码是不会发生死锁的，因为所有的锁申请过程都是按照顺序来申请的，不会出现环。
如果把这段代码改成下面这样，就会抛出异常。
def thread_1():
while True:
with acquire(a_lock):
with acquire(e_lock):
with acquire(b_lock):
print('Thread-1')
def thread_2():
while True:
with acquire(c_lock):
with acquire(f_lock):
with acquire(d_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()
time.sleep(10)
输出：
RuntimeError: Lock Order Violation
raise RuntimeError('Lock Order Violation')
RuntimeError: Lock Order Violation原因是两个线程申请锁的过程不是有序的，申请过程要么把这些锁放在一个acquire里面申请，要么嵌套申请的时候按照顺序来嵌套申请。否则申请出现顺序错误就会抛出异常。
再回到文章开头的哲学家问题，怎么让这些哲学家能吃上饭呢？每个哲学家需要两只筷子才能吃上饭，我们让哲学家按照我们提供的规则去申请筷子。
def philosopher(left, right):
while True:
with acquire(left,right):
print(threading.currentThread(), 'eating')
# 创建五只筷子
NSTICKS = 5
chopsticks = [threading.Lock() for n in range(NSTICKS)]
# 模拟哲学家线程
for n in range(NSTICKS):
t = threading.Thread(target=philosopher,
args=(chopsticks[n],chopsticks[(n+1) % NSTICKS]))
t.start()每只筷子都有它的编号，哲学家只能按照顺序来取筷子，不会形成环，所以最终每个哲学家都能吃上饭。