协程
一.协程
1.了解协程
(1)并发:切换 + 保存状态(程序停止等待)
(2)协程的含义:
协程是一种用户态的轻量级线程,即协程是由用户程序自己控制调度的,是组成线程的各个函数
协程本身没有实体,协程是在单线程的
(3)为什么要有协程?
因为想要在单线程内实现并发的效果.
因为Cpython中有GIL锁,限制了在同一个时间点,只能执行一个线程,所有想要在执行一个线程的期间,充分利用CPU的性能,所以才有了想在单线程内饰并发的效果
(4)CPU为什么要切换?
①因为某个程序阻塞了 ②因为某个程序用完了时间片
很明显解决①这个问题才能提高效率,所以想要实现单线程的并发,就要解决在单线程内,多个任务函数中,某个任务函数遇见IO操作,马上自动切换到其它任务函数去执行
2.yield生成器的特点
yield生成器自带保存状态
例如:
def consumer():
while 1:
x = yield
print(x)
def product():
g = consumer() #实例化一个对象 调用consumer函数,此时不执行consumer函数
next(g) #此时执行consumer函数,但是执行到x = yield的时候就停止了,因为没有参数
for i in range(100): #循环遍历
g.send(i) #为yield传值 传完值之后,光标就在yield后面停止 等到下次执行的时候,继续先从x执行
print("这是product函数")
product() #首先调用product函数
例如:
def func():
sum = 0
while 1:
yield sum
g = func() #当程序执行到这里的时候,并不会执行func函数
print(next(g)) #遇到第一个next(g)的时候从头到尾执行函数,一直执行到yield,然后光标停在yield后面
print(next(g)) #第二次执行的时候,就直接从while循环开始执行
总结:
(1)yield只能实现单纯的切换函数和保存函数的状态的功能,不能够实现当某一个函数遇到IO操作阻塞时,自动地切换到另一个函数去执行
(2)变成协程的目标:当某一个函数遇到IO操作阻塞时候,会自动地切换到另一个函数去执行,如果能实现这个功能,那么每一个函数都是一个协程,但是协程的本质还是依靠于yield实现的
(3)如果只是拿yield去单纯的实现一个切换现象,你就会发现根本没有程序串行执行效率高
3.greenlet模块
能简单的实现函数与函数之间的切换,但是遇到IO操作,不能自动切换到其他函数中
(1)注册一下,函数func,将函数注册成一个对象f
f = greenlet(func)
(2)调用func,使用f.switch(),如果func需要传参,就在switch这里传参即可
当使用switch调用函数func 的时候,什么时候func会停止?
(1)要么return (2)要么在func内部又遇到了switch
例如:
from greenlet import greenlet
def eat(name):
print("%s吃炸鸡" % name) #执行这句话
f2.switch("牛哞哞") #使用f2.switch调用drink这个函数,并为其传一个名字的参数
print("%s吃蛋糕" % name)
f2.switch() #又使用f2.switch调用drink这个函数
def drink(name):
print("%s喝啤酒" % name) #执行这句话
f1.switch() #又使用f1.switch调用eat函数
print("%s喝可乐" % name)
f1 = greenlet(eat) #首先注册了两个对象,分别是f1和f2
f2 = greenlet(drink)
f1.switch("刘某某") #使用f1.switch调用eat这个函数,并为其传一个名字的参数
4.gevent模块
可以实现在某函数内部遇到IO操作阻塞,就会自动的切换到其它函数内部去执行
g = gevent.spawn(func,参数)
g.join() 让func函数执行完毕
gevent.join([g1,g2,g3]) 让多个函数执行完毕
func停止的原因:
(1)func执行完毕 (2)遇到IO操作的时候
(1)例如:
import gevent
def func():
print("1 2 3 4")
gevent.sleep(1) #遇到IO操作,自动执行另一个函数
print("3 2 3 4")
gevent.sleep(1) #此时gevent不能识别到其它的IO操作,只能识别自己认识的IO操作(gevent.sleep())
def func1():
print("2 2 3 4")
gevent.sleep(1) #再次遇到IO操作,又回到刚才那个函数去执行
print("再来一次")
g1 = gevent.spawn(func) #先注册一个func,将func注册成一个对象g1和g2
g2 = gevent.spawn(func1)
g1.join() #通过g1对象执行func函数
(2)例如:解决gevent不能识别其它的IO操作
from gevent import monkey
import gevent
monkey.patch_all() #可以让gevent识别大部分常用的IO操作
import time
def func():
print("1 2 3 4")
time.sleep(1)
print("3 2 3 4")
def func1():
print("2 2 3 4")
time.sleep(1)
print("再来一次")
g1 = gevent.spawn(func)
g2 = gevent.spawn(func1)
g1.join()
g2.join()
(3)例如:串行和并发的效率对比
并发效率比串行快
from gevent import monkey
monkey.patch_all()
import gevent
import time
def func(num):
time.sleep(1)
print(num)
start = time.time()
for i in range(10): #串行
func(i)
print(time.time() - start)
start = time.time()
l = []
for i in range(10):
g = gevent.spawn(func,i) #协程去并发实现执行任务函数
l.append(g)
gevent.joinall(l) #等待l里面的全部函数执行完毕
print(time.time() - start)
(4)爬虫实例
from gevent import monkey
monkey.patch_all()
import gevent
import time
import requests
def get_result(url):
res = requests.get(url)
print(url,res.status_code,len(res.text))
url_l = ['http://www.baidu.com',
'https://www.jd.com',
'http://www.apache.com',
'http://www.taobao.com',
'http://www.qq.com',
'http://www.mi.com',
'http://www.cnblogs.com']
def sync_func(url_l):
'''同步调用'''
for url in url_l:
get_result(url)
def async_func(url_l):
'''异步'''
l = []
for url in url_l:
l.append(gevent.spawn(get_result,url))
gevent.joinall(l)
start = time.time()
sync_func(url_l)
print('sync:',time.time() - start)
start = time.time()
async_func(url_l)
print('async:',time.time() - start)
5.大的总结 (面试题)
(1)协程是由用户自己去调度的
(2)计算密集用多进程,可以充分利用多核CPU的性能
(3)IO密集用多线程(协程是单线程的)
(4)多线程和协程的区别:
①线程是由操作系统调度,控制
②协程是由程序员自己调度,控制
二.IO多路复用
1.阻塞IO
2.非阻塞IO
3.多路复用IO
4.异步IO (python实现不了,但是有tornado框架,天生自带异步)
例子一:用非阻塞IO模型解决阻塞IO
服务器端代码:
import socket
sk = socket.socket()
sk.setblocking(False)
sk.bind(('127.0.0.1',8080))
sk.listen()
l = []
del_l = []
while 1:
try:
conn,addr = sk.accept()# 如果是阻塞IO模型，在这里程序会一直等待。
l.append(conn)# 将每个请求连接的客户端的conn添加到列表中
except BlockingIOError:
for conn in l:# 去遍历所有客户端的conn，看看有没有客户端给我发送数据了
try:
info = conn.recv(1024).decode('utf-8')# 尝试接收，看看有没有客户端给我发数据
if not info:# 如果客户端正常执行了close，服务器会接收到一个空
del_l.append(conn)# 将已经结束的客户端的conn，添加到要删除的列表中
print('客户端正常退出了!')
conn.close()# 因为客户端已经主动close，所以服务器端的conn也要close
else:
print(info)
conn.send(info.upper().encode('utf-8'))
except BlockingIOError:
continue# 是没有接受到客户端发来的数据而报错
except ConnectionResetError:
pass# 是因为客户端强制退出而报错
if del_l:
for conn in del_l:
l.remove(conn)
del_l = []# 在删除完主动关闭的客户端的连接之后，应该把此列表清空，否则报错
客户端代码:
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
while 1:
msg_s = input('>>>')
if not msg_s:continue
if msg_s == 'q':break
sk.send(msg_s.encode('utf-8'))
print(sk.recv(1024).decode('utf-8'))
sk.close()
例子二:基于select的网络IO模型
服务器端代码:
import select
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
del_l = []
rlist = [sk]# 是用来让select帮忙监听的 所有 接口
# select：windows/linux是监听事件有没有数据到来
# poll: linux 也可以做select的工作
# epoll: linux 也可以做类似的工作
while 1:
r,w,x = select.select(rlist,[],[])# 传参给select，当rlist列表中哪个接口有反应，就返回给r这个列表
if r:
for i in r:# 循环遍历r，看看有反应的接口到底是sk 还是conn
if i == sk:
# 如果是sk，那就表示有客户端的连接请求
'''sk有数据要接收，代表着有客户端要来连接'''
conn,addr = i.accept()
rlist.append(conn)# 把新的客户端的连接，添加到rlist，继续让select帮忙监听
else:
# 如果是conn，就表示有客户端给我发数据了
'''conn有数据要接收，代表要使用recv'''
try:
msg_r = i.recv(1024).decode('utf-8')
if not msg_r:
'''客户端执行了close，客户端主动正常关闭连接'''
del_l.append(i)
i.close()
else:
print(msg_r)
i.send(msg_r.upper().encode('utf-8'))
except ConnectionResetError:
pass
if del_l:# 删除那些主动断开连接的客户端的conn
for conn in del_l:
rlist.remove(conn)
del_l.clear()
客户端代码:
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
while 1:
msg_s = input('>>>')
if not msg_s:continue
if msg_s == 'q':break
sk.send(msg_s.encode('utf-8'))
print(sk.recv(1024).decode('utf-8'))
sk.close()
面试题
select 和 poll 和 epoll区别
(1)select 和 poll 有一个共同的机制,都是采用轮询的方式去询问内核,有没有数据准备好了
(2)select 有一个最大监听事件的限制,32位机限制1024,6位机限制2048
(3)poll没有,理论上poll可以开启无限大,1G内存大概够你开10W个事件去监听
(4)epoll是最好的,采用的是回调机制,解决了select和poll共同存在的问题
而且epoll理论上也可以开启无限多个监听事件
