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

每只筷子都有它的编号，哲学家只能按照顺序来取筷子，不会形成环，所以最终每个哲学家都能吃上饭。



本人是做大数据开发的，在微信上开了个个人号，会经常在上面分享一些学习心得，原创文章都会首发到公众号上，感兴趣的盆友可以关注下哦！

备注：微信公众号搜索‘大数据入坑指南‘