day31 协程
2024-09-03 05:51:54
day31 协程
一、死锁与递归锁
所谓死锁：是指两个或者两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，也就是死锁
1.1死锁
from threading import Thread,Lock
import time
lock1 = Lock()
lock2 = lock1
def eat1(name):
lock1.acquire()
print('%s抢到了面条'% name)
time.sleep(1)
lock2.acquire()
print('%s抢到了筷子'% name)
time.sleep(1)
lock2.release()
print('%s放下了筷子'% name)
time.sleep(1)
print('%s放下了面条'% name)
lock1.release()
def eat2(name):
lock2.acquire()
print('%s抢到了筷子'% name)
time.sleep(1)
lock1.acquire()
print('%s抢到了面条'% name)
time.sleep(1)
lock1.release()
print('%s放下了面条'% name)
time.sleep(1)
print('%s放下了筷子'% name)
lock2.release()
if __name__ == '__main__':
for name in ['zhang','meng','song']:
t = Thread(target=eat1,args=(name, ))
t.start()
for name in ['bai','liu','hu']:
t1 = Thread(target=eat2,args=(name, ))
t1.start()
输出结果：eat1中zhang抢到了面条，但是eat2中bai抢到了筷子，谁都等待对方先给，这就造成了死锁
# 解决方法：递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁：RLock。
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁。
1.2、递归锁（重入锁）
from threading import Thread,Lock,RLock
import time
# lock1 = Lock()
# lock2 = lock1
lock1 = RLock() # 递归锁
lock2 = lock1
def eat1(name):
lock1.acquire()
print('%s抢到了面条'% name)
time.sleep(1)
lock2.acquire()
print('%s抢到了筷子'% name)
time.sleep(1)
lock2.release()
print('%s放下了筷子'% name)
time.sleep(1)
print('%s放下了面条'% name)
lock1.release()
def eat2(name):
lock2.acquire()
print('%s抢到了筷子'% name)
time.sleep(1)
lock1.acquire()
print('%s抢到了面条'% name)
time.sleep(1)
lock1.release()
print('%s放下了面条'% name)
time.sleep(1)
print('%s放下了筷子'% name)
lock2.release()
if __name__ == '__main__':
for name in ['zhang','meng','song']:
t = Thread(target=eat1,args=(name, ))
t.start()
for name in ['bai','liu','hu']:
t1 = Thread(target=eat2,args=(name, ))
t1.start()
结果：顺利的执行代码
二、线程队列
queue队列：使用import queue（小写q）,用法与进程Queue一样
'''
同一个进程下多个线程数据是共享的
为什么先同一个进程下还会去使用队列呢
因为队列是：管道+锁
所以用队列还是为了保证数据的安全
'''
2.1、先进先出
import queue
q=queue.Queue()
q.put('first')
q.put('second')
q.put('third')
print(q.get())
print(q.get())
print(q.get())
'''
结果(先进先出):
first
second
third
'''
2.2、后进先出
import queue
q=queue.LifoQueue() # LifoQueue函数是为后进先出
q.put('first')
q.put('second')
q.put('third')
print(q.get())
print(q.get())
print(q.get())
'''
结果(后进先出):
third
second
first
'''
2.3、优先级队列
import queue
q=queue.PriorityQueue() # 作用时候为优先级
#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
q.put((20,'a'))
q.put((10,'b'))
q.put((30,'c'))
print(q.get())
print(q.get())
print(q.get())
'''
结果(数字越小优先级越高,优先级高的优先出队):
(10, 'b')
(20, 'a')
(30, 'c')
'''
三、进程池与线程池
3.1、基本用法
一、介绍：
1.concurrent.futures模块提供了高度封装的异步调用接口
2.ThreadPoolExecutor：线程池，提供异步调用
3.ProcessPoolExecutor:进程池，提供异步调用
二、基本方法：
1.submit(fn,*args,**kwargs)：异步提交任务
2.map()：在submit中和for循环一样的作用
3.shutdown():相当于p.join
4.result(timeout=None):取得结果
5.add_done_callback(fu):回调函数
6.done():判断一个线程是否完成
7.cancle():取消某个任务
代码：
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
def task(n,m):
print(n)
print(m)
if __name__ == '__main__':
p_fool = ProcessPoolExecutor(3) # 同时只有3个进程执行，把进程池换成线程池，操作一样
p_fool.submit(task,n=1,m=2) # 提交函数
p_fool.shutdown() # 相当于join
print('=====>')
输出结果：1,2，===>
3.2、回调函数：add_done_callback()
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
def task(n,m):
return n + m
# 回调函数
def foo(res):
print(res.result())
if __name__ == '__main__':
p_fool = ProcessPoolExecutor(3)
p_fool.submit(task,n=1,m=2).add_done_callback(foo) # 回调函数
返回结果：3
3.3、map的用法
# map的用法
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time,random
def task(n):
print('my is %s'% os.getpid())
time.sleep(random.randint(1,3))
return n ** 2
if __name__ == '__main__':
t_fool = ThreadPoolExecutor(3)
t_fool.map(task,range(1,12)) # 和下方for循环一样的功能
# for i in range(1, 12):
# t_fool.submit(task, i)
四、协程
1、协程介绍：
协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。一句话说明什么是协程：协程是一种用户态的轻量级线程，既协程是由用户程序自己控制调度的。
需要强调的是：
1.python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程执行）
2.单线程内开启协程，一旦遇到io，就会从高应用程序级别（而非操作系统）控制切换，从此来提升效率。
对比操作系统控制线程的切换，用户在单线程内控制协程的切换。
# 优点：
1.协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
2.单线程内就可以实现并发的效果，更大限度地利用cpu
# 缺点：
1.协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
2.协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程
# 协程特点：
1.必须在只有一个单线程里实现并发
2.修改共享数据不需加锁
3.用户程序里自己保存多个控制流的上下文栈
4.一个协程遇到io操作自动切换到其他协程
五、协程之greenlet模块
greenlet作用：当切到一个任务时如果遇到io，拿就原地堵塞，仍然是没有解决遇到io自动切换来提升效率问题。# 我们完全可以遇到阻塞，就利用阻塞的时间去执行任务。
from greenlet import greenlet
def eat(name):
print('%s吃一口' % name)
g2.switch(name)
print('%s再吃一口'% name)
g2.switch()
def play(name):
print('%s玩下手机'%name)
g1.switch()
print('%s再玩下手机'% name)
g1 = greenlet(eat)
g2 = greenlet(play)
g1.switch('meng') # 可以在第一次switch时传入参数，以后都不需要
输出结果：
'''
meng吃一口
meng玩下手机
meng再吃一口
meng再玩下手机
'''
六、协程之Gevent模块
Gevent介绍：Gevent是一个第三方库，可以轻松通过gevent实现并发同步或者异步编程，在gevent中用到的主要模式是Greenlet，它是以c扩展模块形式接入python的轻量级协程。Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。
代码：
import gevent
import time
from gevent import monkey # 加入猴子补丁之后也可以用time.sleep()来切换
monkey.patch_all()
def eat(name):
print('my is eat1 %s'% name)
gevent.sleep(2) # 可以切换打印吹来
# time.sleep(2) # 不能切换打印出来
print('my is eat2 %s'% name)
def play(name):
print('my is play1 or %s'% name)
gevent.sleep(2)
# time.sleep(2)
print('my is play2 or %s'% name)
g1 = gevent.spawn(eat,'lqz')
g2 = gevent.spawn(play,'lqz')
g1.join()
g2.join()
gevent.sleep()输出结果：
'''
my is eat1 lqz
my is play1 or lqz
my is eat2 lqz
my is play2 or lqz
'''
time.sleep()输出结果:
'''
my is eat1 lqz
my is play1 or lqz
my is eat2 lqz
my is play2 or lqz
'''
最新文章
- [2015hdu多校联赛补题]hdu5348 MZL's endless loop
- iOS 设置navigationBar背景
- 【原创】 SharePoint Service Unavaliable
- Word Pattern | & II
- 当一个JavaScripter初次进入PHP的世界，他将看到这样的风景
- python自动化运维常用模块安装
- servlet文件上传及下载
- CentOS Linux搭建SVN服务器
- 尝试Java，从入门到Kotlin（下）
- Java多线程10：join()方法
- 7.2 if else 语句
- 一点感悟：《Node.js学习笔记》star数突破1000+
- Struts2 REST 插件 XStream 远程代码执行漏洞 S2-052 复现过程
- 使用python调用淘宝的ip地址库查询接口结合zabbix判断dnspod域名解析是否正确
- 基于Flume的日志收集系统方案参考
- Tensorflow检验GPU是否安装成功 及 使用GPU训练注意事项
- Logo的制作
- 两个int（32位）整数m和n的二进制表达中，有多少个位(bit)不同
- Linux服务器有什么优势？
- Android高级_第三方下载工具Volley