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

作者:goldensun 时间:2023-12-21 07:35:03 

一、死锁

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

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

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

标签:Python,锁
0
投稿

猜你喜欢

  • redis不能访问本机真实ip地址的解决方案

    2023-07-05 13:09:44
  • python使用BeautifulSoup分析网页信息的方法

    2022-02-07 11:33:40
  • SQL Server中关于基数估计计算预估行数的一些方法探讨

    2024-01-14 17:30:40
  • Runnable.com 在线测试代码片分享网站

    2023-02-04 09:25:54
  • windows下cx_Freeze生成Python可执行程序的详细步骤

    2022-12-06 05:27:57
  • python函数常见关键字分享

    2022-06-17 04:31:55
  • VSCODE添加open with code实现右键打开文件夹

    2022-02-06 05:09:43
  • 详解python数据结构之栈stack

    2023-02-12 17:48:56
  • golang Gorm框架讲解

    2024-04-25 13:19:09
  • XML简易教程之二

    2008-09-05 17:19:00
  • python获取地震信息 微信实时推送

    2021-05-10 17:42:01
  • Python中的list.sort()方法和函数sorted(list)

    2021-07-29 17:02:23
  • JavaScript设计模式之代理模式简单实例教程

    2024-04-22 12:54:07
  • vue中控制mock在开发环境使用,在生产环境禁用方式

    2024-05-21 10:15:06
  • 微信小程序中的canvas 文字断行和省略号显示功能的处理方法

    2023-08-25 02:53:35
  • 怎样使MySQL在攻击者面前保持安全

    2008-11-17 20:09:00
  • MySql 5.6.14 Win32位免安装解压缩版配置教程

    2024-01-13 01:27:44
  • Python pickle模块用法实例

    2022-06-30 10:29:04
  • python虚拟机之描述器实现原理与源码分析

    2022-05-24 14:41:10
  • Python多进程模式实现多核CPU并行计算

    2022-12-01 21:26:20
  • asp之家 网络编程 m.aspxhome.com