1. 全栈程序员必看首页

死锁与递归锁及信号量等[通俗易懂]

全栈程序员-用户IM • • 未分类

死锁与递归锁进程也是有死锁的所谓死锁：是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死

大家好，又见面了，我是你们的朋友全栈君。

死锁与递归锁

进程也是有死锁的

所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，

它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，

如下就是死锁

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

1 死锁-------------------
 2 from  threading import Thread,Lock,RLock
 3 import time
 4 mutexA = Lock()
 5 mutexB = Lock()
 6 class MyThread(Thread):
 7     def run(self):
 8         self.f1()
 9         self.f2()
10     def f1(self):
11         mutexA.acquire()
12         print('3[33m%s 拿到A锁 '%self.name)
13         mutexB.acquire()
14         print('3[45%s 拿到B锁 '%self.name)
15         mutexB.release()
16         mutexA.release()
17     def f2(self):
18         mutexB.acquire()
19         print('3[33%s 拿到B锁 ' % self.name)
20         time.sleep(1)  #睡一秒就是为了保证A锁已经被别人那到了
21         mutexA.acquire()
22         print('3[45m%s 拿到B锁 ' % self.name)
23         mutexA.release()
24         mutexB.release()
25 if __name__ == '__main__':
26     for i in range(10):
27         t = MyThread()
28         t.start() #一开启就会去调用run方法

死锁现象

那么怎么解决死锁现象呢？

解决方法，递归锁：在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。

直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁

mutexA=mutexB=threading.RLock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，<br>则counter继续加1，这期间所有其他线程都只能等待，等待该线程释放所有锁，
即counter递减到0为止

如何解决死锁：

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

1 # 2.解决死锁的方法--------------递归锁
 2 from  threading import Thread,Lock,RLock
 3 import time
 4 mutexB = mutexA = RLock()
 5 class MyThread(Thread):
 6     def run(self):
 7         self.f1()
 8         self.f2()
 9     def f1(self):
10         mutexA.acquire()
11         print('3[33m%s 拿到A锁 '%self.name)
12         mutexB.acquire()
13         print('3[45%s 拿到B锁 '%self.name)
14         mutexB.release()
15         mutexA.release()
16     def f2(self):
17         mutexB.acquire()
18         print('3[33%s 拿到B锁 ' % self.name)
19         time.sleep(1)  #睡一秒就是为了保证A锁已经被别人拿到了
20         mutexA.acquire()
21         print('3[45m%s 拿到B锁 ' % self.name)
22         mutexA.release()
23         mutexB.release()
24 if __name__ == '__main__':
25     for i in range(10):
26         t = MyThread()
27         t.start() #一开启就会去调用run方法

解决方案

二、信号量Semaphore（其实也是一把锁）

Semaphore管理一个内置的计数器

Semaphore与进程池看起来类似，但是是完全不同的概念。

进程池：Pool(4)，最大只能产生四个进程，而且从头到尾都只是这四个进程，不会产生新的。

信号量：信号量是产生的一堆进程/线程，即产生了多个任务都去抢那一把锁

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

1 from threading import Thread,Semaphore,currentThread
 2 import time,random
 3 sm = Semaphore(5) #运行的时候有5个人
 4 def task():
 5     sm.acquire()
 6     print('3[42m %s上厕所'%currentThread().getName())
 7     time.sleep(random.randint(1,3))
 8     print('3[31m %s上完厕所走了'%currentThread().getName())
 9     sm.release()
10 if __name__ == '__main__':
11     for i in range(20):  #开了10个线程 ，这20人都要上厕所
12         t = Thread(target=task)
13         t.start()

Semaphore示例

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

1 hread-1上厕所
 2  Thread-2上厕所
 3  Thread-3上厕所
 4  Thread-4上厕所
 5  Thread-5上厕所
 6  Thread-3上完厕所走了
 7  Thread-6上厕所
 8  Thread-1上完厕所走了
 9  Thread-7上厕所
10  Thread-2上完厕所走了
11  Thread-8上厕所
12  Thread-6上完厕所走了
13  Thread-5上完厕所走了
14  Thread-4上完厕所走了
15  Thread-9上厕所
16  Thread-10上厕所
17  Thread-11上厕所
18  Thread-9上完厕所走了
19  Thread-12上厕所
20  Thread-7上完厕所走了
21  Thread-13上厕所
22  Thread-10上完厕所走了
23  Thread-8上完厕所走了
24  Thread-14上厕所
25  Thread-15上厕所
26  Thread-12上完厕所走了
27  Thread-11上完厕所走了
28  Thread-16上厕所
29  Thread-17上厕所
30  Thread-14上完厕所走了
31  Thread-15上完厕所走了
32  Thread-17上完厕所走了
33  Thread-18上厕所
34  Thread-19上厕所
35  Thread-20上厕所
36  Thread-13上完厕所走了
37  Thread-20上完厕所走了
38  Thread-16上完厕所走了
39  Thread-18上完厕所走了
40  Thread-19上完厕所走了

运行结果

三、Event

线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行

from threading import Event
Event.isSet() #返回event的状态值
Event.wait() #如果 event.isSet()==False将阻塞线程；
Event.set() #设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；
Event.clear() #恢复

示例1.，有多个工作线程尝试链接MySQL，我们想要在链接前确保MySQL服务正常才让那些工作线程去连接MySQL服务器，如果连接不成功，都会去尝试重新连接。那么我们就可以采用threading.Event机制来协调各个工作线程的连接操作

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

1 #首先定义两个函数，一个是连接数据库
 2 # 一个是检测数据库
 3 from threading import Thread,Event,currentThread
 4 import time
 5 e = Event()
 6 def conn_mysql():
 7     '''链接数据库'''
 8     count = 1
 9     while not e.is_set():  #当没有检测到时候
10         if count >3: #如果尝试次数大于3，就主动抛异常
11             raise ConnectionError('尝试链接的次数过多')
12         print('3[45m%s 第%s次尝试'%(currentThread(),count))
13         e.wait(timeout=1) #等待检测（里面的参数是超时1秒）
14         count+=1
15     print('3[44m%s 开始链接...'%(currentThread().getName()))
16 def check_mysql():
17     '''检测数据库'''
18     print('3[42m%s 检测mysql...' % (currentThread().getName()))
19     time.sleep(5)
20     e.set()
21 if __name__ == '__main__':
22     for i  in range(3):  #三个去链接
23         t = Thread(target=conn_mysql)
24         t.start()
25     t = Thread(target=check_mysql)
26     t.start()

详情

示例2：红绿灯的例子

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

1 from  threading import Thread,Event,currentThread
 2 import time
 3 e = Event()
 4 def traffic_lights():
 5     '''红绿灯'''
 6     time.sleep(5)
 7     e.set()
 8 def car():
 9     '''车'''
10     print('3[42m %s 等绿灯3[0m'%currentThread().getName())
11     e.wait()
12     print('3[44m %s 车开始通行' % currentThread().getName())
13 if __name__ == '__main__':
14     for i in range(10):
15         t = Thread(target=car)  #10辆车
16         t.start()
17     traffic_thread = Thread(target=traffic_lights)  #一个红绿灯
18     traffic_thread.start()

红绿灯

四、定时器（Timer）

指定n秒后执行某操作

from threading import Timer
def func(n):
    print('hello,world',n)
t = Timer(3,func,args=(123,))  #等待三秒后执行func函数，因为func函数有参数，那就再传一个参数进去
t.start()

五、线程queue

queue队列 ：使用import queue，用法与进程Queue一样

queue.Queue(maxsize=0) #先进先出

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

1 # 1.队列-----------
2 import queue
3 q = queue.Queue(3) #先进先出
4 q.put('first')
5 q.put('second')
6 q.put('third')
7 print(q.get())
8 print(q.get())
9 print(q.get())

View Code

queue.LifoQueue(maxsize=0)#先进后出

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

1 # 2.堆栈----------
2 q = queue.LifoQueue() #先进后出（或者后进先出）
3 q.put('first')
4 q.put('second')
5 q.put('third')
6 q.put('for')
7 print(q.get())
8 print(q.get())
9 print(q.get())

View Code

queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

 1 # ----------------
 2 '''3.put进入一个元组，元组的第一个元素是优先级
 3 （通常也可以是数字，或者也可以是非数字之间的比较）
 4 数字越小，优先级越高'''
 5 q = queue.PriorityQueue()
 6 q.put((20,'a'))
 7 q.put((10,'b'))  #先出来的是b,数字越小优先级越高嘛
 8 q.put((30,'c'))
 9 print(q.get())
10 print(q.get())
11 print(q.get())

View Code

六、多线程性能测试

1.多核也就是多个CPU
（1）cpu越多，提高的是计算的性能
（2）如果程序是IO操作的时候（多核和单核是一样的），再多的cpu也没有意义。
2.实现并发
第一种：一个进程下，开多个线程
第二种：开多个进程
3.多进程：
   优点：可以利用多核
   缺点：开销大
4.多线程
   优点：开销小
   缺点：不可以利用多核
5多进程和多进程的应用场景
   1.计算密集型：也就是计算多，IO少
     如果是计算密集型，就用多进程（如金融分析等）
   2.IO密集型：也就是IO多，计算少
     如果是IO密集型的，就用多线程（一般遇到的都是IO密集型的）

练习示例：

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

1 # 计算密集型的要开启多进程
 2 from  multiprocessing import Process
 3 from threading import Thread
 4 import time
 5 def work():
 6     res = 0
 7     for i in range(10000000):
 8         res+=i
 9 if __name__ == '__main__':
10     l = []
11     start = time.time()
12     for i in range(4):
13         p = Process(target=work)  #1.9371106624603271  #可以利用多核（也就是多个cpu）
14         # p  = Thread(target=work)  #3.0401737689971924
15         l.append(p)
16         p.start()
17     for p in l:
18         p.join()
19     stop = time.time()
20     print('%s'%(stop-start))

计算密集型

死锁与递归锁及信号量等[通俗易懂]
死锁与递归锁及信号量等[通俗易懂] 

 1 # I/O密集型要开启多线程
 2 from multiprocessing import Process
 3 from threading import Thread
 4 import time
 5 def work():
 6     time.sleep(3)
 7 if __name__ == '__main__':
 8     l = []
 9     start = time.time()
10     for i in range(400):
11         # p = Process(target=work)  #34.9549994468689   #因为开了好多进程，它的开销大，花费的时间也就长了
12         p = Thread(target=work) #2.2151265144348145  #当开了多个线程的时候，它的开销小，花费的时间也小了
13         l.append(p)
14         p.start()
15     for i in l :
16         i.join()
17     stop = time.time()
18     print('%s'%(stop-start))

I/O密集型

七、python标准模块—-concurrent.futures

 

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/124481.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0
blank

相关推荐

  • KTT条件的理解「建议收藏」

    KTT条件的理解「建议收藏」

    KTT条件的理解「建议收藏」求解优化问题：对于等式约束条件，使用拉格朗日乘子法求；对于不等式约束条件，使用KTT条件求解；这两种方法求得结果只是必要条件，只有当目标函数是凸函数时，才是充分必要条件。着重讲一下KTT条件求解如下优化问题：minxf(x)s.t.gi(x)≤0(j=1,…,n)minxf(x)s.t.gi(x)≤0(j=1,…,n)min_{x}f(x)\nonumber\\…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月25日
  • Cortex m33_STM32F4

    Cortex m33_STM32F4

    Cortex m33_STM32F4Cortex-M3Bit-Banding1.概述CM3的存储器系统支持所谓的“位带”（bit-band）操作。通过它，实现了对单一bit的原子操作。位带操作仅适用于一些特殊的存储器区域中。从汇编角度看：与传统方法的比较：在位带区中，每个比特都映射到别名地址区的一个字——这是个只有LSB才有效的字。支持位带操作的两个内存区的范围是：**0x2000_0000-0x

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年8月31日
  • 怎么样CSDN Blog投机和增加流量?

    怎么样CSDN Blog投机和增加流量?

    怎么样CSDN Blog投机和增加流量?

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年1月7日
  • H.264/MPEG-4 AVC学习

    H.264/MPEG-4 AVC学习

    H.264/MPEG-4 AVC学习转自：https://www.freehacker.cn/media/codec-h264/简述H.264，又称为MPEG-4第10部分，高级视频编码（英语：MPEG-4Part10,AdvancedVideoCoding，缩写为MPEG-4AVC）是一种面向块的基于运动补偿的视频编码标准。对于视频序列样本来说，使用H.264编码器能够比使用有运动补偿的MPEG-…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年9月19日
  • python中md5加密的实现

    python中md5加密的实现

    python中md5加密的实现python中md5加密的实现MD5消息摘要算法:(英语：MD5Message-DigestAlgorithm)，一种被广泛使用的密码散列函数，可以产生出一个128位(16字节)的散列值(hashvalue)，用于确保信息传输完整一致。MD5是最常见的摘要算法，速度很快，生成结果是固定的128bit字节，通常用一个32位的16进制字符串表示。Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年7月11日
  • pycharm安装教程CSDN_java遇到解决不了的问题

    pycharm安装教程CSDN_java遇到解决不了的问题

    pycharm安装教程CSDN_java遇到解决不了的问题第三周开始接触python了，结果第一步装pycharm时就遇到了坑，正常安装完成后点运行时出现错误——NoJVMinstallationfound。助教说这是缺少jdk(java程序支持包)，需要在网上找个最新的安装并配置下path路径。唉，编程小白，完全不知道这都是些啥o(╥﹏╥)o，于是开始了百度解决问题之路……运行pycharm错误——NoJVMinstallationfoun…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年8月26日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号