31、Python程序中的协程操作(greenlet\gevent模块)
一、协程介绍
协程:是单线程下的并发,又称微线程,纤程。英文名Coroutine。一句话说明什么是协程:协程是一种用户态的轻量级线程,即协程是由用户程序自己控制调度的。
对比操作系统控制线程的切换,用户在单线程内控制协程的切换。
协程自己本身无法实现并发(甚至性能会降低)。
协程+IO切换性能提高。
优点如下:
- 协程的切换开销更小,属于程序级别的切换,操作系统完全感知不到,因而更加轻量级
- 单线程内就可以实现并发的效果,最大限度地利用cpu
缺点如下:
- 协程的本质是单线程下,无法利用多核,可以是一个程序开启多个进程,每个进程内开启多个线程,每个线程内开启协程
- 协程指的是单个线程,因而一旦协程出现阻塞,将会阻塞整个线程
总结协程特点:
- 必须在只有一个单线程里实现并发
- 修改共享数据不需加锁
- 用户程序里自己保存多个控制流的上下文栈
- 附加:一个协程遇到IO操作自动切换到其它协程(如何实现检测IO,yield、greenlet都无法实现,就用到了gevent模块(select机制))
二、greenlet模块
1、安装模块
安装:pip3 install greenlet
2、greenlet实现状态切换
from greenlet import greenlet def eat(name):
print('%s eat 1' % name)
g2.switch('nick')
print('%s eat 2' % name)
g2.switch() def play(name):
print('%s play 1' % name)
g1.switch()
print('%s play 2' % name) g1 = greenlet(eat)
g2 = greenlet(play) g1.switch('nick') # 可以在第一次switch时传入参数,以后都不需要
单纯的切换(在没有io的情况下或者没有重复开辟内存空间的操作),反而会降低程序的执行速度。
3、效率对比
#顺序执行
import time
def f1():
res=1
for i in range(100000000):
res+=i def f2():
res=1
for i in range(100000000):
res*=i start=time.time()
f1()
f2()
stop=time.time()
print('run time is %s' %(stop-start)) #10.985628366470337 #切换
from greenlet import greenlet
import time
def f1():
res=1
for i in range(100000000):
res+=i
g2.switch() def f2():
res=1
for i in range(100000000):
res*=i
g1.switch() start=time.time()
g1=greenlet(f1)
g2=greenlet(f2)
g1.switch()
stop=time.time()
print('run time is %s' %(stop-start)) # 52.763017892837524
greenlet只是提供了一种比generator更加便捷的切换方式,当切到一个任务执行时如果遇到io,那就原地阻塞,仍然是没有解决遇到IO自动切换来提升效率的问题。
单线程里的这20个任务的代码通常会既有计算操作又有阻塞操作,我们完全可以在执行任务1时遇到阻塞,就利用阻塞的时间去执行任务2...如此,才能提高效率,这就用到了Gevent模块。
三、gevent模块
1、安装
安装:pip3 install gevent
2、Gevent模块介绍
Gevent 是一个第三方库,可以轻松通过gevent实现并发同步或异步编程,在gevent中用到的主要模式是Greenlet,它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部,但它们被协作式地调度。
1、 用法介绍
g1=gevent.spawn(func,1,,2,3,x=4,y=5):创建一个协程对象g1,spawn括号内第一个参数是函数名,如eat,后面可以有多个参数,可以是位置实参或关键字实参,都是传给函数eat的
g2=gevent.spawn(func2)
g1.join():等待g1结束
g2.join():等待g2结束 #上述两步合成一步:
gevent.joinall([g1,g2])
g1.value
:拿到func1的返回值
2、遇到io主动切换
import geventdef eat(name):
print('%s eat 1' %name)
gevent.sleep(2)
print('%s eat 2' %name) def play(name):
print('%s play 1' %name)
gevent.sleep(1)
print('%s play 2' %name) g1=gevent.spawn(eat,'egon')
g2=gevent.spawn(play,name='egon')
g1.join()
g2.join()
# 或者gevent.joinall([g1,g2])
print('主')
上例gevent.sleep(2)
模拟的是gevent可以识别的io阻塞,而time.sleep(2)
或其他的阻塞,gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了。
from gevent import monkey;monkey.patch_all()
必须放到被打补丁者的前面,如time,socket模块之前。或者我们干脆记忆成:要用gevent,需要将from gevent import monkey;monkey.patch_all()
放到文件的开头。
from gevent import monkey;monkey.patch_all() import gevent
import time
def eat():
print('eat food 1')
time.sleep(2)
print('eat food 2') def play():
print('play 1')
time.sleep(1)
print('play 2') g1=gevent.spawn(eat)
g2=gevent.spawn(play)
gevent.joinall([g1,g2])
print('主')
3、 查看threading.current_thread().getName()
我们可以用threading.current_thread().getName()
来查看每个g1和g2,查看的结果为DummyThread-n,即假线程
from gevent import monkey;monkey.patch_all()
import threading
import gevent
import time
def eat():
print(threading.current_thread().getName())
print('eat food 1')
time.sleep(2)
print('eat food 2') def play():
print(threading.current_thread().getName())
print('play 1')
time.sleep(1)
print('play 2') g1=gevent.spawn(eat)
g2=gevent.spawn(play)
gevent.joinall([g1,g2])
print('主')
3、Gevent之同步与异步
from gevent import spawn,joinall,monkey;monkey.patch_all() import time
def task(pid):
"""
Some non-deterministic task
"""
time.sleep(0.5)
print('Task %s done' % pid) def synchronous(): # 同步
for i in range(10):
task(i) def asynchronous(): # 异步
g_l=[spawn(task,i) for i in range(10)]
joinall(g_l)
print('DONE') if __name__ == '__main__':
print('Synchronous:')
synchronous()
print('Asynchronous:')
asynchronous()
# 上面程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。
# 初始化的greenlet列表存放在数组threads中,此数组被传给gevent.joinall 函数,
# 后者阻塞当前流程,并执行所有给定的greenlet任务。执行流程只会在 所有greenlet执行完后才会继续向下走。
4、Gevent之应用
通过gevent实现单线程下的socket并发
注意:from gevent import monkey;monkey.patch_all()
一定要放到导入socket模块之前,否则gevent无法识别socket的阻塞。
1、 服务端
from gevent import monkey;monkey.patch_all()
from socket import *
import gevent #如果不想用money.patch_all()打补丁,可以用gevent自带的socket
# from gevent import socket
# s=socket.socket() def server(server_ip,port):
s=socket(AF_INET,SOCK_STREAM)
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
s.bind((server_ip,port))
s.listen(5)
while True:
conn,addr=s.accept()
gevent.spawn(talk,conn,addr) def talk(conn,addr):
try:
while True:
res=conn.recv(1024)
print('client %s:%s msg: %s' %(addr[0],addr[1],res))
conn.send(res.upper())
except Exception as e:
print(e)
finally:
conn.close() if __name__ == '__main__':
server('127.0.0.1',8080)
2、多线程并发多个客户端
from threading import Thread
from socket import *
import threading def client(server_ip,port):
c=socket(AF_INET,SOCK_STREAM) #套接字对象一定要加到函数内,即局部名称空间内,放在函数外则被所有线程共享,则大家公用一个套接字对象,那么客户端端口永远一样了
c.connect((server_ip,port)) count=0
while True:
c.send(('%s say hello %s' %(threading.current_thread().getName(),count)).encode('utf-8'))
msg=c.recv(1024)
print(msg.decode('utf-8'))
count+=1
if __name__ == '__main__':
for i in range(500):
t=Thread(target=client,args=('127.0.0.1',8080))
t.start()
四、五种IO模型
五种I/O模型包括:阻塞I/O、非阻塞I/O、信号驱动I/O、I/O多路转接、异步I/O。其中,前四个被称为同步I/O。
1、阻塞I/O模型
在linux中,默认情况下所有的socket都是blocking,除非特别指定,几乎所有的I/O接口 ( 包括socket接口 ) 都是阻塞型的。
如果所面临的可能同时出现的上千甚至上万次的客户端请求,“线程池”或“连接池”或许可以缓解部分压力,但是不能解决所有问题。总之,多线程模型可以方便高效的解决小规模的服务请求,但面对大规模的服务请求,多线程模型也会遇到瓶颈,可以用非阻塞接口来尝试解决这个问题。
2、非阻塞I/O模型
在非阻塞式I/O中,用户进程其实是需要不断的主动询问kernel数据准备好了没有。但是非阻塞I/O模型绝不被推荐。
非阻塞,不等待。比如创建socket对某个地址进行connect、获取接收数据recv时默认都会等待(连接成功或接收到数据),才执行后续操作。
如果设置setblocking(False),以上两个过程就不再等待,但是会报BlockingIOError的错误,只要捕获即可。
异步,通知,执行完成之后自动执行回调函数或自动执行某些操作(通知)。比如做爬虫中向某个地址baidu。com发送请求,当请求执行完成之后自执行回调函数。
3、多路复用I/O模型(事件驱动)
基于事件循环的异步非阻塞框架:如Twisted框架,scrapy框架(单线程完成并发)。
检测多个socket是否已经发生变化(是否已经连接成功/是否已经获取数据)(可读/可写)IO多路复用作用?
检测多个socket是否发生变化。
操作系统检测socket是否发生变化,有三种模式:
- select:最多1024个socket;循环去检测。
- poll:不限制监听socket个数;循环去检测(水平触发)。
- epoll:不限制监听socket个数;回调方式(边缘触发)。
Python模块:
- select.select
- select.epoll
基于IO多路复用+socket非阻塞#,实现并发请求(一个线程100个请求)
import socket
# 创建socket
client = socket.socket()
# 将原来阻塞的位置变成非阻塞(报错)
client.setblocking(False) # 百度创建连接: 阻塞
try:
# 执行了但报错了
client.connect(('www.baidu.com',80))
except BlockingIOError as e:
pass # 检测到已经连接成功 # 问百度我要什么?
client.sendall(b'GET /s?wd=alex HTTP/1.0\r\nhost:www.baidu.com\r\n\r\n') # 我等着接收百度给我的回复
chunk_list = []
while True:
# 将原来阻塞的位置变成非阻塞(报错)
chunk = client.recv(8096)
if not chunk:
break
chunk_list.append(chunk) body = b''.join(chunk_list)
print(body.decode('utf-8'))
4、信号驱动I/O模型(了解)
5、异步I/O模型
上五个模型的阻塞程度由低到高为:阻塞I/O>非阻塞I/O>多路转接I/O>信号驱动I/O>异步I/O,因此他们的效率是由低到高的。
31、Python程序中的协程操作(greenlet\gevent模块)的更多相关文章
- Python程序中的协程操作-greenlet模块
目录 一.安装模块 二.greenlet实现状态切换 三.效率对比 一.安装模块 安装:pip3 install greenlet 二.greenlet实现状态切换 from greenlet imp ...
- Python程序中的协程操作-gevent模块
目录 一.安装 二.Gevent模块介绍 2.1 用法介绍 2.2 例:遇到io主动切换 2.3 查看threading.current_thread().getName() 三.Gevent之同步与 ...
- python中的协程:greenlet和gevent
python中的协程:greenlet和gevent 协程是一中多任务实现方式,它不需要多个进程或线程就可以实现多任务. 1.通过yield实现协程: 代码: import time def A(): ...
- python网络编程-协程(协程说明,greenlet,gevent)
一:什么是协程 协程(Coroutine):,又称微线程.协程是一种用户态的轻量级线程.是由用户自己控制,CPU根本不知道协程存在. 协程拥有自己的寄存器上下文和栈. 协程调度切换时,将寄存器上下文和 ...
- 协程及Python中的协程
1 协程 1.1协程的概念 协程,又称微线程,纤程.英文名Coroutine.一句话说明什么是线程:协程是一种用户态的轻量级线程.(其实并没有说明白~) 我觉得单说协程,比较抽象,如果对线程有一定了解 ...
- Python中Paramiko协程方式详解
什么是协程 协程我们可以看做是一种用户空间的线程. 操作系统对齐存在一无所知,需要用户自己去调度. 比如说进程,线程操作系统都是知道它们存在的.协程的话是用户空间的线程,操作系统是不知道的. 为什么要 ...
- python中的协程及实现
1.协程的概念: 协程是一种用户态的轻量级线程.协程拥有自己的寄存器上下文和栈. 协程调度切换时,将寄存器上下文和栈保存到其他地方,在切换回来的时候,恢复先前保存的寄存器上下文和栈. 因此,协程能保留 ...
- Python中异步协程的使用方法介绍
1. 前言 在执行一些 IO 密集型任务的时候,程序常常会因为等待 IO 而阻塞.比如在网络爬虫中,如果我们使用 requests 库来进行请求的话,如果网站响应速度过慢,程序一直在等待网站响应,最后 ...
- 在Python程序中的进程操作,multiprocess.Process模块
在python程序中的进程操作 之前我们已经了解了很多进程相关的理论知识,了解进程是什么应该不再困难了,刚刚我们已经了解了,运行中的程序就是一个进程.所有的进程都是通过它的父进程来创建的.因此,运行起 ...
随机推荐
- 《Linux就该这么学》自学笔记_ch22_使用openstack部署云计算服务环境
<Linux就该这么学>自学笔记_ch22_使用openstackb部署云计算服务环境 文章主要内容: 了解云计算 Openstack项目 服务模块组件详解 安装Openstack软件 使 ...
- C语言学习系列笔记
1.小甲鱼 C语言教程系列
- kali无法安装nvidia显卡驱动
按照各位大神的博客安装nvidia显卡驱动一直失败,重启之后无法正常进入系统,恢复模式可以进入,一直以为自己是不是哪里步骤不对,后面来回重装了几次系统. 最后意识到虚拟机里用的是虚拟网卡,并非宿主机的 ...
- QuantLib 金融计算——案例之普通欧式期权分析
目录 QuantLib 金融计算--案例之普通欧式期权分析 概述 普通欧式期权公式法定价 1. 配置期权合约条款 2. 构建期权对象 3. 配置定价引擎 4. 计算 题外话:天数计算规则 Quote ...
- POJ-最大连续子序列和
给定一个整数序列,找到一个具有最大和的连续子序列(子序列最少包含一个元素),返回其最大和. 实例输入: -2, 1, -3, 4, -1, 2, 1, -5, 4 实例输出: 6(连续子序列4, -1 ...
- 关于C语言中整数范围的一些解释
示例代码 #include <stdio.h> int main() { ; printf("%d\n", c); ; printf("%d\n", ...
- 复习:C语言基础知识1
占位符: %d, %i,代表整数,%f-浮点,%s,字符串,%c,char. %p 指针,%fL 长long,%e科学计数,%g 小数或科学计数. C语言中的格式占位符: %a,%A 读入一个浮点值( ...
- Java学习:数据类型转换注意事项
数据类型的转换 当数据类型不一样时,将会发生数据类型转换. 自动类型转换(隐式) 1.特点 :代码不需要进行特殊处理,自动完成. 2.规则 :数据范围从小到大. //左边是long类型,右边是默认的i ...
- NETCore使用带有权限验证的Swagger
原文:NETCore使用带有权限验证的Swagger 文章目录 Swagger 什么是Swagger NuGet安装 Startup注册Swagger 设置默认首页打开Swagger 为接口添加注释 ...
- systemd - CentOS 7进程守护&监控
需求: 运行环境为CentOS 7系统,我们开发了一个程序,需要在开机时启动它,当程序进程crash或者开机之后,守护进程立即拉起进程. 解决方案: 使用CentOS 7中的init进程systemd ...