python死锁案例_Python 多线程死锁

最新推荐文章于 2022-09-13 16:08:03 发布
最新推荐文章于 2022-09-13 16:08:03 发布
阅读量122 收藏
点赞数
文章标签： python死锁案例

场景是这样的：开启多个线程访问外部 api ，过一段时间，发现所有线程死锁。

环境： python2.6.7 centos7.1 urllib2 ， suse 下无此问题。

dump 如下：

Thread 161 (Thread 0x7f80de4e9700 (LWP 12459)):

#0 0x00007f80e4cacb6c in __lll_lock_wait_private () from /lib64/libc.so.6

#1 0x00007f80e4cc2efd in _L_lock_746 () from /lib64/libc.so.6

#2 0x00007f80e4cc2cb5 in __check_pf () from /lib64/libc.so.6

#3 0x00007f80e4c88f69 in getaddrinfo () from /lib64/libc.so.6

#4 0x00007f80e12faa3c in socket_getaddrinfo (self=, args=) at /home/basic/Python-2.7.6/Modules/socketmodule.c:4198

#5 0x00000000004b5726 in call_function (oparg=, pp_stack=0x7f80de4e6b30) at Python/ceval.c:4021

#6 PyEval_EvalFrameEx ([email protected]=0x7f7fa403c980, [email protected]=0) at Python/ceval.c:2666

看上去是 getaddrinfo 引发的死锁，不知道大家没有遇到这个坑，请大家帮忙给些建议，谢谢！

weixin_39558804
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python 多线程中死锁了怎么办？
编程的朝圣之路
09-29 360
一、死锁 在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。 就好像在现实社会中，男女双方在闹别扭之后，都在等待对方先道歉。 如果双方都这样固执地等待对方先开口，弄不好，就 over 了。 尽管死锁很少发生，但一旦发生就会造成应用的停止响应。 下面看一个死锁的例子： import threading import time class MyThread1(threading.Thread): def run(self): # 对mut
python死锁案例_python 模拟死锁
weixin_39978863的博客
12-06 155
python 模拟死锁#在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。尽管死锁很少发生，但一旦发生就会造成应用的停止响应。如下例子：第一个方法lock_1先获取mutexA锁，访问全局变量globalvarA，然后acquiremutexB锁第二个方法lock_2先获取mutexB锁，访问全局变量globakvarB，...
Python多线程的死锁
youcijibi的博客
02-09 191
import threading import time def test1(): if mutex_a.acquire(): print(str(threading.current_thread()) + '----do1----up') time.sleep(1) if mutex_b.acquire(): print(str(threading.current_thread()) + '----do1---down'.
python—多线程之死锁
python全栈
10-15 2926
一、造成死锁的原因 1、在多线程程序中，死锁问题很大一部分是由于线程同时获取多个锁造成的。 2、在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。 3、尽管死锁很少发生，但一旦发生就会造成应用的停止响应。 二、产生死锁的四个原因 1、互斥条件:一个资源每次只能被一个线程使用。 2、请求与保持条件:一个线程因请求资源而阻塞时，对已获得的资源保持不放。3、不剥夺条件:线程已获得的资源，在末使用完之前，不能强行剥夺。 4、循环等待条件:若干线程之间形成一种头尾相接的循
Python 多线程死锁
houyanhua1的专栏
10-13 478
import threading import time mutexA=threading.Lock() #创建一个锁 mutexB=threading.Lock() #创建一个锁 class threadA(threading.Thread): def run(self): if mutexA.acquire(1): #锁定成功就继续执行，锁定不成功，就一直等待
PYthon-multithreading-Test.rar_python_python 多线程_python多线程_多线程
09-19
本压缩包“PYthon-multithreading-Test.rar”包含了有关Python多线程测试的源码，旨在帮助用户深入理解和实践Python的线程操作。 Python中的多线程是通过`threading`模块实现的，这个模块提供了基本的线程和同步...
python 多线程死锁问题的解决方案
01-21
就是当多线程访问多个锁的时候，不同的锁被不同的线程持有，它们都在等待其他线程释放出锁来，于是便陷入了永久等待。比如A线程持有1号锁，等待2号锁，B线程持有2号锁等待1号锁，那么它们永远也等不到执行的那天，...
multithreading of python.rar_python多线程
09-15
Python的多线程是Python编程中的一个重要概念，特别是在处理大量数据或者需要同时执行多个任务时。在Python 2.x版本中，多线程是通过`threading`模块来实现的。下面将详细介绍Python 2.x版本中的多线程以及相关的...
Python多线程编程（五）：死锁的形成
12-25
前一篇文章Python：使用threading模块实现多线程编程四[使用Lock互斥锁]我们已经开始涉及到如何使用互斥锁来保护我们的公共资源了，现在考虑下面的情况– 如果有多个公共资源，在线程间共享多个资源的时候，如果两个...
python死锁案例_python避免死锁方法实例分析
weixin_39618730的博客
12-06 49
本文实例讲述了python避免死锁方法。分享给大家供大家参考。具体分析如下：当两个或者更多的线程在等待资源的时候就会产生死锁，两个线程相互等待。在本文实例中 thread1 等待thread2释放block , thread2等待thtead1释放ablock，避免死锁的原则：1. 一定要以一个固定的顺序来取得锁，这个列子中，意味着首先要取得alock, 然后再去block2. 一定要按照与取得锁...
Python3-多线程死锁问题
zbrj12345的博客
04-02 2275
#1、死锁:前提是有多个锁 ''' 在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源时，就会造成死锁。 尽管死锁很少发生，但一旦发生就会造成应用的停止响应。 ''' #2、例子： #有两个人分别做“西兰花”和“红烧肉”，每个人都需要“锅”和“铲子”才能炒菜。 import threading,time class XiLanHua_Thread(threadi...
多任务之死锁
汪云辉的博客
10-17 263
死锁1. 死锁的概念2. 死锁示例3. 避免死锁 1. 死锁的概念 死锁: 一直等待对方释放锁的情景就是死锁 为了更好的理解死锁，来看一个现实生活的效果图: 说明: 现实社会中，男女双方一直等待对方先道歉的这种行为就好比是死锁。 死锁的结果 会造成应用程序的停止响应，不能再处理其它任务了。 2. 死锁示例 需求: 根据下标在列表中取值, 保证同一时刻只能有一个线程去取值 import threading import time # 创建互斥锁 lock = threading.Lock() #
飘逸的python - 演示一种死锁的产生
mattkang
10-07 4234
搞多线程的经常会遇到死锁的问题，学习操作系统的时候会讲到死锁相关的东西，我们用python直观的演示一下。 死锁的一个原因是互斥锁。假设银行系统中，用户a试图转账100块给用户b，与此同时用户b试图转账200块给用户a，则可能产生死锁。 2个线程互相等待对方的锁，互相占用着资源不释放。 #coding=utf-8 import time import threading class Acco
Python多线程 threading模块[5] 死锁的形成
╮(╯_╰)╭ Don't expect me to reply to you in time
03-26 348
前一篇文章Python：《Python多线程 threading模块 Lock互斥锁》我们已经开始涉及到如何使用互斥锁来保护我们的公共资源了，现在考虑下面的情况： 如果有多个公共资源，在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，这会引起什么问题？ 死锁概念 所谓死锁： 是指两个或两个以上的进程在执行过程中，...
Python 多线程死锁的示例
haeasringnar的博客
05-25 469
在 Python 中多线程中为了防止资源竞争而出现问题，提供了锁的机制，当一个线程操作资源时进行加锁，操作完毕后释放锁，这样其他线程就不会同时操作资源导出出现异常。 在 Python 多线程中注意是两种锁：互斥锁和递归锁 那么它们有什么区别呢？ 互斥锁： 一旦一个线程获得一个互斥锁，会阻塞随后尝试获得锁的线程，直到它被释放；任何线程都可以释放它。 递归锁： 递归锁必须由获取它的线程释放。一旦线程获得了递归锁，同一个线程再次获取它将不阻塞；线程必须在每次获取它时释放一次。 虽然锁可以防止程序出问题，但是使用锁
python写一个死锁_用python写个死锁
weixin_39906192的博客
01-29 219
#coding:utf8import threadingimport timenum = 0lock = threading.Lock()def func(n):lock.acquire()print nif(n == 5):print "到我这就锁死了"raise Exception('大死锁之术!')lock.release()if __name__ == "__main__":t4 = th...
Python面试题--第69道题目--线程锁是什么，如何使用线程锁--2022年04月24日
蓝星部队的博客
05-04 283
1、线程锁的核心目的：就是为了保证数据的一致性，对线程锁内的资源（变量）进行锁定，避免其它线程偷偷进行篡改。以达到我们的预期效果。即：异步变同步。 2、为什么需要线程锁：由于多线程同时在完成特定的操作时，所以在完成操作的过程中可能会被打断，去做其他的操作，可能会产生脏数据。
Python 并发编程之死锁
m0_72829928的博客
09-13 1034
在并发编程中，死锁指的是一种特定的情况，即无法取得进展，程序被锁定在其当前状态。在大多数情况下，这种现象是由于不同的锁对象（用于线程同步）之间缺乏协调，或者处理不当造成的。在这一节中，我们将讨论一个思想实验，通常被称为餐饮哲学家问题，以说明死锁的概念及其原因；从这里开始，你将学习如何在 Python 并发程序中模拟这个问题。本文首先介绍了并发编程中的经典问题——哲学家就餐问题，然后引出了死锁的概念及条件。然后给出了可能出现死锁的情况，并通过 Python 代码模拟哲学家就餐问题和模拟死锁的四种情况。
python 线程锁_对python多线程中Lock()与RLock()锁详解
最新发布
05-31
在 Python 中，多线程编程是很常见的操作。但是多线程编程必然涉及到对共享资源的读写操作，而这很容易引起竞争条件，从而导致数据的不一致性。为了解决这个问题，Python 提供了 Lock 和 RLock 两种锁机制。 1. Lock Lock 是最简单的锁机制，也是最常用的锁机制。它通过 acquire() 方法获得锁，通过 release() 方法释放锁。当一个线程获得了锁，其他线程就不能再获得这个锁，直到这个线程释放锁为止。 下面是一个简单的例子： ```python import threading lock = threading.Lock() def func(): lock.acquire() print('Hello, world!') lock.release() t = threading.Thread(target=func) t.start() ``` 这个例子中，首先创建了一个 Lock 对象，然后定义了一个 func 函数，在函数中先获得锁，然后输出一句话，最后释放锁。在创建一个线程并执行这个函数时，输出的结果是： ``` Hello, world! ``` 在这个例子中，只有一个线程获得了锁，其他线程不能再获得这个锁，所以输出的结果只有一行。 2. RLock RLock 是可重入锁，它可以被一个线程多次 acquire()，而不会发生死锁。这个锁机制可以用在递归函数中，因为递归函数可能会多次调用自身。 下面是一个简单的例子： ```python import threading lock = threading.RLock() def func(): lock.acquire() print('Hello, world!') lock.acquire() print('Hello, again!') lock.release() lock.release() t = threading.Thread(target=func) t.start() ``` 这个例子中，首先创建了一个 RLock 对象，然后定义了一个 func 函数，在函数中先获得锁，输出一句话，再次获得锁，输出另一句话，最后释放锁。在创建一个线程并执行这个函数时，输出的结果是： ``` Hello, world! Hello, again! ``` 在这个例子中，虽然 func 函数中多次获得了锁，但是由于使用的是可重入锁，所以不会发生死锁，输出的结果也是正确的。 总结： Lock 和 RLock 都是 Python 中常用的锁机制，Lock 是最简单的锁机制，而 RLock 是可重入锁，可以在递归函数中使用。在多线程编程中，使用这两个锁机制可以有效地避免竞争条件，保证数据的一致性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值