并发编程---死锁||递归锁---信号量---Event事件---定时器
死锁
互斥锁:Lock(),互斥锁只能acquire一次
递归锁: RLock(),可以连续acquire多次,每acquire一次计数器+1,只有计数为0时,才能被抢到acquire
# 死锁
from threading import Thread,Lock
import time mutexA = 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 time mutexB = 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,random sm=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 in Thread-4 in Thread-5 in
Thread-6 in Thread-7 in Thread-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 time event = 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 time event = Event() def conn():
n=0
while not event.is_set():
if n == 3:
print('%s try too many' %currentThread().getName())
return
print('%s try %s' %(currentThread().getName(),n))
event.wait(0.5)
n+=1 print('%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 random class 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 res def check(self):
while True:
code = input('输入你的验证码>>: ').strip()
if code.upper() == self.cache:
print('验证码输入正确')
self.t.cancel()
break obj=Code()
obj.check() '''
打印结果:
X095
输入你的验证码>>: X095
验证码输入正确
'''
定时器
并发编程---死锁||递归锁---信号量---Event事件---定时器的更多相关文章
- python并发编程-多线程实现服务端并发-GIL全局解释器锁-验证python多线程是否有用-死锁-递归锁-信号量-Event事件-线程结合队列-03
目录 结合多线程实现服务端并发(不用socketserver模块) 服务端代码 客户端代码 CIL全局解释器锁****** 可能被问到的两个判断 与普通互斥锁的区别 验证python的多线程是否有用需 ...
- GIL全局解释器锁-死锁与递归锁-信号量-event事件
一.全局解释器锁GIL: 官方的解释:掌握概念为主 """ In CPython, the global interpreter lock, or GIL, is a m ...
- 8.14 day32 TCP服务端并发 GIL解释器锁 python多线程是否有用 死锁与递归锁 信号量event事件线程q
TCP服务端支持并发 解决方式:开多线程 服务端 基础版 import socket """ 服务端 1.要有固定的IP和PORT 2.24小时不间断提供服务 3.能够支 ...
- 递归锁,event事件和信号量
锁通常被用来实现对共享资源的同步访问.为每一个共享资源创建一个Lock对象,当你需要访问该资源时,调用acquire方法来获取锁对象(如果其它线程已经获得了该锁,则当前线程需等待其被释放),待资源访问 ...
- 死锁与递归锁 信号量 event 线程queue
1.死锁现象与递归锁 死锁:是指两个或两个以上的进程或线程在执行过程中,因争抢资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去,此时称系统处于死锁状态或系统产生了死锁,这些永远在互相 ...
- 线程 Thread类 GIL锁 信号量 Event事件
线程的开启方法 进程是操作系统调度的最小单位,一个进程最少有一个主线程,而一个进程中可以开启多个线程 from threading import Thread def task(): print('A ...
- 同步锁 死锁与递归锁 信号量 线程queue event事件
二个需要注意的点: 1 线程抢的是GIL锁,GIL锁相当于执行权限,拿到执行权限后才能拿到互斥锁Lock,其他线程也可以抢到GIL,但如果发现Lock任然没有被释放则阻塞,即便是拿到执行权限GIL也要 ...
- GIL 信号量 event事件 线程queue
GIL全局解释器锁 官方解释: In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple n ...
- Python进阶----线程基础,开启线程的方式(类和函数),线程VS进程,线程的方法,守护线程,详解互斥锁,递归锁,信号量
Python进阶----线程基础,开启线程的方式(类和函数),线程VS进程,线程的方法,守护线程,详解互斥锁,递归锁,信号量 一丶线程的理论知识 什么是线程: 1.线程是一堆指令,是操作系统调度 ...
随机推荐
- [Full-stack] 世上最好语言 - PHP
前言 本篇是对个人PHP, Laravel系列博文的总结与思考. 目的在于理清并熟练如下过程: "需求 --> Usercase --> UI --> 框架 --> ...
- lua第三方库
一.Lua 包管理工具 1.LuaRocks luarocks 是Lua常用的包管理工具(还有一个是LuaDist),其安装方式请参考官网:https://luarocks.org/#quick-st ...
- 【转】MYSQL-CLUSTER-7.5搭建数据库集群
阅读目录 前言 mysql cluster中的几个概念解释 架构图及说明 下载mysql cluster 安装mysql cluster之前 安装配置管理节点 安装配置数据和mysql节点 测试 启动 ...
- cordova 插件 调用iOS社交化分享(ShareSDK:微信QQ分享)
1.github上已有的插件:https://github.com/nwpuhmz/ShareSDKPlugin 2.安装插件 cordova plugin add https://github.co ...
- 录制用户的音频,视屏 navigator.mediaDevices.getUserMedia
google 文档 HACKS 文档 相关代码 获取本地的音频 <input type="file" accept="audio/*" capture=& ...
- js fetch api
MDN fatch 返回的对象 type string url string redirected boolean status number ok boolean statusText string ...
- VBS数组导入Excel
<script language="vbscript"> dim arr(9999,4) for i=0 to 9999 for j = 0 to 4 arr(i,j) ...
- UVALive - 6185 Find the Outlier暴力填表+高斯消元+卡eps
https://cn.vjudge.net/problem/UVALive-6185 我真的是服了orz eps 1e5,1e6过不了 开1e2 1e1都能过 题意:给你一个d阶多项式f的f(0),f ...
- Python使用xml.dom解析xml
在菜鸟教程上找了个关于电影信息的xml类型的文档,用python内置的xml.dom来解析提取一下信息. 先复习一下xml概念: XML 指可扩展标记语言(EXtensible Markup Lang ...
- 快速排序javascript实现
快速排序基本思想: 以升序为例 数组arr,数组个数n; 1.选取一个待排序的元素.一般选第一个位置作为基准值temp=arr[0]. 2.选取带排序数组的两端元素的位置作为哨兵的位置,左端为哨兵i, ...