举例讲解Python中的死锁、可重入锁和互斥锁

举例讲解Python中的死锁、可重入锁和互斥锁

一、死锁

简单来说,死锁是一个资源被多次调用,而多次调用方都未能释放该资源就会造成死锁,这里结合例子说明下两种常见的死锁情况。

举例讲解Python中的死锁、可重入锁和互斥锁

1、迭代死锁

该情况是一个线程“迭代”请求同一个资源,直接就会造成死锁:

import threading

import time

class MyThread(threading.Thread):

  def run(self):

    global
num

   
time.sleep(1)

    if
mutex.acquire(1):

     
num = num 1

     
msg = self.name ' set num to ' str(num)

     
print msg

     
mutex.acquire()

     
mutex.release()

     
mutex.release()

num = 0

mutex = threading.Lock()

def test():

  for i in range(5):

    t =
MyThread()

   
t.start()

if __name__ == '__main__':

  test()

上例中,在run函数的if判断中第一次请求资源,请求后还未 release
,再次acquire,最终无法释放,造成死锁。这里例子中通过将print下面的两行注释掉就可以正常执行了
,除此之外也可以通过可重入锁解决,后面会提到。

2、互相调用死锁

上例中的死锁是在同一个def函数内多次调用造成的,另一种情况是两个函数中都会调用相同的资源,互相等待对方结束的情况。如果两个线程分别占有一部分资源并且同时等待对方的资源,就会造成死锁。

import threading

import time

class MyThread(threading.Thread):

  def do1(self):

    global resA,
resB

    if
mutexA.acquire():

      
msg = self.name ' got resA'

      
print msg

      
if mutexB.acquire(1):

        
msg = self.name ' got resB'

        
print msg

        
mutexB.release()

      
mutexA.release()

  def do2(self):

    global resA,
resB

    if
mutexB.acquire():

      
msg = self.name ' got resB'

      
print msg

      
if mutexA.acquire(1):

        
msg = self.name ' got resA'

        
print msg

        
mutexA.release()

      
mutexB.release()

  def run(self):

   
self.do1()

   
self.do2()

resA = 0

resB = 0

mutexA = threading.Lock()

mutexB = threading.Lock()

def test():

  for i in range(5):

    t =
MyThread()

   
t.start()

if __name__ == '__main__':

  test()

这个死锁的示例稍微有点复杂。具体可以理下。

二、可重入锁

为了支持在同一线程中多次请求同一资源,python提供了“可重入锁”:threading.RLock。RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的acquire都被release,其他的线程才能获得资源。这里以例1为例,如果使用RLock代替Lock,则不会发生死锁:

import threading

import time

class MyThread(threading.Thread):

  def run(self):

    global
num

   
time.sleep(1)

    if
mutex.acquire(1):

     
num = num 1

     
msg = self.name ' set num to ' str(num)

     
print msg

     
mutex.acquire()

     
mutex.release()

     
mutex.release()

num = 0

mutex = threading.RLock()

def test():

  for i in range(5):

    t =
MyThread()

   
t.start()

if __name__ == '__main__':

  test()

和上面那个例子的不同之处在于threading.Lock()换成了threading.RLock() 。

三、互斥锁

python threading模块有两类锁:互斥锁(threading.Lock
)和可重用锁(threading.RLock)。两者的用法基本相同,具体如下:

lock = threading.Lock()

lock.acquire()

dosomething……

lock.release()

RLock的用法是将threading.Lock()修改为threading.RLock()。便于理解,先来段代码:

[root@361way lock]# cat lock1.py

    

#!/usr/bin/env python

# coding=utf-8

import
threading             
# 导入threading模块

import
time              
# 导入time模块

class
mythread(threading.Thread):   
# 通过继承创建类

  def
__init__(self,threadname):   #
初始化方法

    #
调用父类的初始化方法

   
threading.Thread.__init__(self,name = threadname)

  def
run(self):            
# 重载run方法

    global
x        
# 使用global表明x为全局变量

    for i in
range(3):

     
x = x 1

   
time.sleep(5)    
# 调用sleep函数,让线程休眠5秒

    print
x

tl =
[]              
# 定义列表

for i in range(10):

  t =
mythread(str(i))       
# 类实例化

 
tl.append(t)          
# 将类对象添加到列表中

x=0                
# 将x赋值为0

for i in tl:

  i.start() 

这里执行的结果和想想的不同,结果如下:  
 

[root@361way lock]# python lock1.py

    

30

30

30

30

30

30

30

30

30

30

为什么结果都是30呢?关键在于global 行和 time.sleep行。

1、由于x是一个全局变量,所以每次循环后 x 的值都是执行后的结果值;

2、由于该代码是多线程的操作,所以在sleep
等待的时候,之前已经执行完成的线程会在这等待,而后续的进程在等待的5秒这段时间也执行完成 ,等待print。同样由于global
的原理,x被重新斌值。所以打印出的结果全是30 ;

3、便于理解,可以尝试将sleep等注释,你再看下结果,就会发现有不同。

在实际应用中,如抓取程序等,也会出现类似于sleep等待的情况。在前后调用有顺序或打印有输出的时候,就会现并发竞争,造成结果或输出紊乱。这里就引入了锁的概念,上面的代码修改下,如下:

[root@361way lock]# cat lock2.py

    

#!/usr/bin/env python

# coding=utf-8

import
threading             
# 导入threading模块

import
time              
# 导入time模块

class
mythread(threading.Thread):         
# 通过继承创建类

  def
__init__(self,threadname):        
# 初始化方法

   
threading.Thread.__init__(self,name = threadname)

  def
run(self):            
# 重载run方法

    global
x           
# 使用global表明x为全局变量

   
lock.acquire()          
# 调用lock的acquire方法

    for i in
range(3):

     
x = x 1

   
time.sleep(5)     
# 调用sleep函数,让线程休眠5秒

    print
x

   
lock.release()       
# 调用lock的release方法

lock =
threading.Lock()       
# 类实例化

tl =
[]            
# 定义列表

for i in range(10):

  t =
mythread(str(i))     
# 类实例化

 
tl.append(t)      
# 将类对象添加到列表中

x=0           
# 将x赋值为0

for i in tl:

 
i.start()          
# 依次运行线程



执行的结果如下:

    

[root@361way lock]# python lock2.py

    

3

6

9

12

15

18

21

24

27

30

加锁的结果会造成阻塞,而且会造成开锁大。会根据顺序由并发的多线程按顺序输出,如果后面的线程执行过快,需要等待前面的进程结束后其才能结束
--- 写的貌似有点像队列的概念了 ,不过在加锁的很多场景下确实可以通过队列去解决。

上一篇:selenium之 chromedriver与chrome版本映射表(更新至v2.46)


下一篇:uboot1.1.6