python自学成才之路死锁的解决方案

本文主要是介绍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 = acquiredtry:for lock in locks:lock.acquire()yieldfinally:# 所有的锁使用完之后，按照倒序的方式进行释放，也就是从大到小的顺序进行释放for lock in reversed(locks):lock.release()del acquired[-len(locks):]

这段代码从语法的角度来看可能有两个地方不理解，一个是@contextmanager这个注解，这是上下文管理器的注解，作用和with是一样的，关于这一段可以查看我之前的文章。

第二个不好理解的地方是acquired = getattr(_local,‘acquired’,[])这段代码，这段代码的意思是获取线程本地对象的acquired这个属性，如果没有这个属性则创建一个这样的属性，并赋予初始值[]。

怎么去使用这个上下文管理器呢？看下面这个案例，有三个线程，每个线程都需要申请多个锁，他们申请的锁有些是三个线程都需要的有些是每个线程各自独有的，这些锁都通个acquire这个上下文管理器来获取。


import timea_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 Violationraise 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()