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

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



本人是做大数据开发的,在微信上开了个个人号,会经常在上面分享一些学习心得,原创文章都会首发到公众号上,感兴趣的盆友可以关注下哦!
在这里插入图片描述
备注:微信公众号搜索‘大数据入坑指南‘

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 代码科技 设计师:Amelia_0503 返回首页