死锁

互斥锁:Lock(),互斥锁只能acquire一次

递归锁:  RLock(),可以连续acquire多次,每acquire一次计数器+1,只有计数为0时,才能被抢到acquire

# 死锁
from threading import Thread,Lock
import timemutexA = Lock()
mutexB = Lock()class MyThread(Thread):def run(self):self.f1()self.f2()def f1(self):mutexA.acquire()print('%s 拿到了A锁' %self.name)mutexB.acquire()print('%s 拿到了B锁' % self.name)mutexB.release()mutexA.release()def f2(self):mutexB.acquire()print('%s 拿到了B锁' % self.name)time.sleep(0.1)mutexA.acquire()print('%s 拿到了A锁' % self.name)mutexB.release()mutexA.release()if __name__ == '__main__':for i in range(10):t=MyThread()t.start()
'''
打印结果:
Thread-1 拿到了A锁
Thread-1 拿到了B锁
Thread-1 拿到了B锁
Thread-2 拿到了A锁
'''

死锁

#互斥锁只能acquire一次
from threading import Thread,Lock
mutexA = Lock()
mutexA.acquire()
mutexA.release()#递归锁:可以连续acquire多次,每acquier一次计数器就+1,只有计数为0时,才能被其他线程强到
from threading import Thread,RLock
import timemutexB = mutexA = RLock()class MyThread(Thread):def run(self):self.f1()self.f2()def f1(self):mutexA.acquire()print('%s 拿到了A锁' %self.name)mutexB.acquire()print('%s 拿到了B锁' % self.name)mutexB.release()mutexA.release()def f2(self):mutexB.acquire()print('%s 拿到了B锁' % self.name)time.sleep(2)mutexA.acquire()print('%s 拿到了A锁' % self.name)mutexB.release()mutexA.release()if __name__ == '__main__':for i in range(10):t=MyThread()t.start()
'''
打印结果:
Thread-1 拿到了A锁
Thread-1 拿到了B锁
Thread-1 拿到了B锁
Thread-1 拿到了A锁
Thread-2 拿到了A锁
Thread-2 拿到了B锁
Thread-2 拿到了B锁
Thread-2 拿到了A锁
Thread-4 拿到了A锁
Thread-4 拿到了B锁
Thread-4 拿到了B锁
Thread-4 拿到了A锁
Thread-6 拿到了A锁
Thread-6 拿到了B锁
Thread-6 拿到了B锁
Thread-6 拿到了A锁
Thread-8 拿到了A锁
Thread-8 拿到了B锁
Thread-8 拿到了B锁
Thread-8 拿到了A锁
Thread-10 拿到了A锁
Thread-10 拿到了B锁
Thread-10 拿到了B锁
Thread-10 拿到了A锁
Thread-5 拿到了A锁
Thread-5 拿到了B锁
Thread-5 拿到了B锁
Thread-5 拿到了A锁
Thread-9 拿到了A锁
Thread-9 拿到了B锁
Thread-9 拿到了B锁
Thread-9 拿到了A锁
Thread-7 拿到了A锁
Thread-7 拿到了B锁
Thread-7 拿到了B锁
Thread-7 拿到了A锁
Thread-3 拿到了A锁
Thread-3 拿到了B锁
Thread-3 拿到了B锁
Thread-3 拿到了A锁
'''

递归锁

信号量

信号量也是一把锁,可以指定信号量为5,对比互斥锁同一时间只能有一个任务抢到锁去执行

信号量同一时间可以有5个任务拿到锁去执行

信号量:同一时间有多个线程在进行

from threading import Thread,Semaphore,currentThread
import time,randomsm=Semaphore(3) #厕所的坑def task():# sm.acquire()# print('%s in' %currentThread.getName())# sm.release()
    with sm:print('%s in' %currentThread().getName())time.sleep(random.randint(2,3))if __name__ == '__main__':for i in range(10):t=Thread(target=task)t.start()
'''
打印结果:
Thread-1 in
Thread-2 in
Thread-3 inThread-4 inThread-5 in
Thread-6 inThread-7 inThread-9 in
Thread-8 in
Thread-10 in
'''

信号量

Event事件

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

from threading import Thread,Event
import timeevent = Event()
# event.wait() 在原地等,指导执行到event.set()
# event.set() 等待结束def student(name):print('学生%s 正在听课' %name)event.wait(2)print('学生%s 课间活动' %name)def teacher(name):print('老师%s 正在授课' %name)time.sleep(5)event.set()if __name__ == '__main__':stu1 = Thread(target=student,args=('alex',))stu2 = Thread(target=student,args=('yang',))stu3 = Thread(target=student,args=('hang',))tea1 = Thread(target=teacher,args=('ding',))stu1.start()stu2.start()stu3.start()tea1.start()
'''
打印结果:
学生alex 正在听课
学生yang 正在听课
学生hang 正在听课
老师ding 正在授课
学生hang 课间活动
学生yang 课间活动
学生alex 课间活动
'''#设置连接的超时时间
from threading import Thread,Event,currentThread
import timeevent = Event()def conn():n=0while not event.is_set():if n == 3:print('%s try too many' %currentThread().getName())returnprint('%s try %s' %(currentThread().getName(),n))event.wait(0.5)n+=1print('%s is connecting' %currentThread().getName())def check():print('%s is checking' %currentThread().getName())time.sleep(5)event.set()if __name__ == '__main__':for i in range(3):t=Thread(target=conn)t.start()t=Thread(target=check)t.start()
'''
打印结果:
Thread-1 try 0
Thread-2 try 0
Thread-3 try 0
Thread-4 is checking
Thread-1 try 1
Thread-3 try 1
Thread-2 try 1
Thread-1 try 2
Thread-3 try 2
Thread-2 try 2
Thread-1 try too many
Thread-3 try too many
Thread-2 try too many
'''

Event

定时器

定时器:隔一段时间,执行一个任务,每启动一个定时器,就等于启动一个线程

t=Timer(5,task,args=('egon',))

t.start()

t.cancel()

# from  threading import Timer
#
# def task(name):
#     print('hello %s' %name)
#
# t=Timer(5,task,args=('egon',))
# t.start()#验证码
from threading import Timer
import randomclass Code:def __init__(self):self.make_cache()def make_cache(self,interval=60):self.cache = self.make_code()print(self.cache)self.t = Timer(interval,self.make_cache)self.t.start()def make_code(self,n=4):res=''for i in range(n):s1 = str(random.randint(0,9))s2 = chr(random.randint(65,90))res+=random.choice([s1,s2])return resdef check(self):while True:code = input('输入你的验证码>>: ').strip()if code.upper() == self.cache:print('验证码输入正确')self.t.cancel()breakobj=Code()
obj.check()'''
打印结果:
X095
输入你的验证码>>: X095
验证码输入正确
'''

定时器

转载于:https://www.cnblogs.com/Mryang123/p/8910367.html

并发编程---死锁||递归锁---信号量---Event事件---定时器相关推荐

  1. GIL+死锁与递归锁+信号量+event事件

    GIL全局解释器锁: GIL本质就是一把互斥锁,相当于执行权限,每个进程内都会存在一把GIL,同一进程内的多个线程 必须抢到GIL之后才能使用Cpython解释器来执行自己的代码,即同一进程下的多个线 ...

  2. 并发编程:并发和并行、多进程、同步异步,阻塞非阻塞、进程同步(进程锁)、线程、GIL全局解释器锁、锁-信号量-Event事件、协程

    文章目录 一. 操作系统的发展史 二. 进程基础 三. 并发和并行 四. 如何开启多进程 五. 进程调度算法(了解) 六. 同步异步,阻塞非阻塞(了解) 1. 状态介绍 2.同步和异步.阻塞和非阻塞 ...

  3. 学习笔记(28):Python网络编程并发编程-死锁与递归锁

    立即学习:https://edu.csdn.net/course/play/24458/296445?utm_source=blogtoedu 1.死锁(Lock()的局限性) 知识点:Lock()只 ...

  4. 036-2018-1028 线程 效率对比 数据共享 同步锁死锁递归锁 守护线程 信号量

    笔记 昨日内容回顾: 队列:Queue 管道 : Pipe ,recv消息的时候 OSError,EOFError,数据不安全的 Manager : 共享数据 , 数据不安全 , 加锁 进程池 : P ...

  5. 并发编程中的锁、条件变量和信号量

    在并发编程中,经常会涉及到锁.条件变量和信号量.本文从并发开始,探究为什么需要它们,它们的概念,实现原理以及应用. 并发简介 并发是指多个事情,在同一时间段内同时发生了.和并发经常一起被提到的是并行. ...

  6. python 线程安全的数据类型_详解python多线程、锁、event事件机制的简单使用

    详解python多线程.锁.event事件机制的简单使用 发布时间:2020-09-25 02:04:12 来源:脚本之家 阅读:117 作者:君惜 线程和进程 1.线程共享创建它的进程的地址空间,进 ...

  7. python学习-----9.7-----GIL、死锁递归锁、信号量,event事件

    GIL介绍 GIL本质就是一把互斥锁,既然是互斥锁,所有互斥锁的本质都一样,都是将并发运行变成串行,以此来控制同一时间内共享数据只能被一个任务所修改,进而保证数据安全.每个进程内都会存在一把GIL,同 ...

  8. python基础--GIL全局解释器锁、Event事件、信号量、死锁、递归锁

    ps:python解释器有很多种,最常见的就是C python解释器 GIL全局解释器锁: GIL本质上是一把互斥锁:将并发变成串行,牺牲效率保证了数据的安全 用来阻止同一个进程下的多个线程的同时执行 ...

  9. Python之路(第三十八篇) 并发编程:进程同步锁/互斥锁、信号量、事件、队列、生产者消费者模型...

    一.进程锁(同步锁/互斥锁) 进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的, 而共享带来的是竞争,竞争带来的结果就是错乱,如何控制,就是加锁处理. 例 ...

  10. 4,GIL全局解释器锁,event事件,信号量

    今日内容 1,GIL全局解释器锁 2,死锁 3,信号量 4,event事件 5,队列一:GIL全局解释器锁 什么是GIL 全局解释器锁: 它的本质也是一把互斥锁,是在CPython解释器锁,将并发变为 ...

最新文章

  1. python可以做什么系统-python什么系统
  2. php星座判断源码,php根据日期判断星座的函数分享
  3. Oracle Data Integrator之代理创建
  4. 6.过滤器(Filter)
  5. spring4笔记----依赖注入的两种形式
  6. c语言程序课程设计过程,C语言课程设计————写下流程图! 谢谢
  7. Java NIO框架Netty教程(三) – Object对象传递
  8. 笨方法学python第二版_笨方法学python II
  9. 曼昆经济学原理_第五版[1].txt.doc
  10. 加密卡华为怎么模拟_华为手机NFC模拟加密的门禁卡详细教程
  11. 医药行业数据分析软件(含非付费)--对比分析
  12. OFDM学习笔记(四)(信道估计简介)
  13. 矩阵的Cholesky 分解
  14. 加壳与脱壳知识点(持续更新)
  15. pythonds模块_python之模块
  16. 【微信小程序】-- 自定义组件 - 数据监听器 (三十四)
  17. 计算机算东西,PCDN边缘计算是个啥东西
  18. 基于微信小程序的物流仓储系统-计算机毕业设计
  19. vue如何split_Vue中的join(),reverse()与 split()函数用法解析
  20. 传感器课程实验:传感器静态特性研究-电涡流传感器位移特性实验

热门文章

  1. JavaMail:邮件发送以及sina、163、QQ服务器不同的解析结果(附图)
  2. NodeJS基础2---1 Promise小球运动
  3. iOS 横竖屏适配 ---masonry
  4. Openfire 4.1.0
  5. init与clinit 与 类的初始化顺序
  6. 这封“领导痛批95后下属”的邮件,句句扎心!
  7. 再见!收费的 XShell,我改用国产良心工具!
  8. 微服务架构及其最重要的10个设计模式
  9. 1 月份 Github 上最热门最有价值的开源项目
  10. 今天我们开通知识星球了~