day035协程、IO多路复用

 

本节内容：

一、协程（重点：gevent)
二、IO多路复用

1、协程

一、引子

本节的主题是基于单线程来实现并发，即只用一个主线程（很明显可利用的cpu只有一个）状况下实现并发，
为此咱们须要先回顾下并发的本质：切换+保存状态

　　cpu正在运行一个任务，会在两种状况下切走去执行其余的任务（切换由操做系统强制控制），
一种状况是该任务发生了阻塞，另一种状况是该任务计算的时间过长或有一个优先级更高的程序替代了它

　　协程本质上就是一个线程，之前线程任务的切换是由操做系统控制的，遇到I/O自动切换，
如今咱们用协程的目的就是较少操做系统切换的开销（开关线程，建立寄存器、堆栈等，在他们之间进行切换等），
在咱们本身的程序里面来控制任务的切换。

　　ps：在介绍进程理论时，说起进程的三种执行状态，而线程才是执行单位，因此也能够将上图理解为线程的三种状态

一：其中第二种状况并不能提高效率，只是为了让cpu可以雨露均沾，实现看起来全部任务都被“同时”执行的效果，

若是多个任务都是纯计算的，这种切换反而会下降效率。
为此咱们能够基于yield来验证。
yield自己就是一种在单线程下能够保存任务运行状态的方法，咱们来简单复习一下：

#1 yiled能够保存状态，yield的状态保存与操做系统的保存线程状态很像，可是yield是代码级别控制的，更轻量级
#2 send能够把一个函数的结果传给另一个函数，以此实现单线程内程序之间的切换

经过yield实现任务切换+保存状态

import time def func1(): for i in range(11): #yield print('这是我第%s次打印啦' % i) time.sleep(1) def func2(): g = func1() #next(g) for k in range(10): print('哈哈，我第%s次打印了' % k) time.sleep(1) #next(g) #不写yield，下面两个任务是执行完func1里面全部的程序才会执行func2里面的程序，有了yield，咱们实现了两个任务的切换+保存状态 func1() func2() 

Python

Copy

单纯的切换反而会下降运行效率

#基于yield并发执行，多任务之间来回切换，这就是个简单的协程的体现，可是他可以节省I/O时间吗？不能 import time def consumer(): '''任务1:接收数据,处理数据''' while True: x=yield # time.sleep(1) #发现什么？只是进行了切换，可是并无节省I/O时间 print('处理了数据：',x) def producer(): '''任务2:生产数据''' g=consumer() next(g) #找到了consumer函数的yield位置 for i in range(3): # for i in range(10000000): g.send(i) #给yield传值，而后再循环给下一个yield传值，而且多了切换的程序，比直接串行执行还多了一些步骤，致使执行效率反而更低了。 print('发送了数据：',i) start=time.time() #基于yield保存状态,实现两个任务直接来回切换,即并发的效果 #PS:若是每一个任务中都加上打印,那么明显地看到两个任务的打印是你一次我一次,即并发执行的. producer() #我在当前线程中只执行了这个函数，可是经过这个函数里面的send切换了另一个任务 stop=time.time() # 串行执行的方式 # res=producer() # consumer(res) # stop=time.time() print(stop-start) 

Python

Copy

二、协程就是告诉Cpython解释器，你不是nb吗，不是搞了个GIL锁吗，

那好，我就本身搞成一个线程让你去执行，省去你切换线程的时间，我本身切换比你切换要快不少，避免了不少的开销，
对于单线程下，咱们不可避免程序中出现io操做，但若是咱们能在本身的程序中（即用户程序级别，而非操做系统级别）
控制单线程下的多个任务能在一个任务遇到io阻塞时就切换到另一个任务去计算，
这样就保证了该线程可以最大限度地处于就绪态，即随时均可以被cpu执行的状态，
至关于咱们在用户程序级别将本身的io操做最大限度地隐藏起来，从而能够迷惑操做系统，
让其看到：该线程好像是一直在计算，io比较少，从而更多的将cpu的执行权限分配给咱们的线程。

　　协程的本质就是在单线程下，由用户本身控制一个任务遇到io阻塞了就切换另一个任务去执行，
以此来提高效率。为了实现它，咱们须要找寻一种能够同时知足如下条件的解决方案：

#1. 能够控制多个任务之间的切换，切换以前将任务的状态保存下来，以便从新运行时，能够基于暂停的位置继续执行。

#2. 做为1的补充：能够检测io操做，在遇到io操做的状况下才发生切换

三、协程介绍

协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。
一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序本身控制调度的。

对比操做系统控制线程的切换，用户在单线程内控制协程的切换
协程在操做系统上是没有这个概念的，是程序员们本身叫的

1.须要强调的是：

1. python的线程属于内核级别的，即由操做系统控制调度
（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其余线程运行）

2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操做系统）控制切换，
以此来提高效率（！！！非io操做的切换与效率无关）

2.优势以下：

1. 协程的切换开销更小，属于程序级别的切换，操做系统彻底感知不到，于是更加轻量级
2. 单线程内就能够实现并发的效果，最大限度地利用cpu

3.缺点以下：

1. 协程的本质是单线程下，没法利用多核，
能够是一个程序开启多个进程，每一个进程内开启多个线程，每一个线程内开启协程
2. 协程指的是单个线程，于是一旦协程出现阻塞，将会阻塞整个线程

4.总结协程特色：

一、必须在只有一个单线程里实现并发
二、修改共享数据不需加锁
三、用户程序里本身保存多个控制流的上下文栈
四、附加：一个协程遇到IO操做自动切换到其它协程
（如何实现检测IO，yield、greenlet都没法实现，就用到了gevent模块（select机制））

四、Greenlet

若是咱们在单个线程内有20个任务，要想实如今多个任务之间切换，
使用yield生成器的方式过于麻烦（须要先获得初始化一次的生成器，而后再调用send。。。很是麻烦），
而使用greenlet模块能够很是简单地实现这20个任务直接的切换

#安装
pip3 install greenlet

1.生成器版的任务切换

import time def func(): for i in range(10): print("来这里") yield # 经过yield记录上一次执行的位置 time.sleep(1) print("%s号完成了" % i) def func1(): g = func() next(g) for i in range(10): time.sleep(1) print("%s号在忙" % i) next(g) # func1() 

Python

Copy

2.效率对比

单纯的切换（在没有io的状况下或者没有重复开辟内存空间的操做），反而会下降程序的执行速度

效率对比

#顺序执行 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 

Python

Copy

3.greenlet只是提供了一种便捷的切换方式，并无提高效率

greenlet只是提供了一种比generator更加便捷的切换方式，
当切到一个任务执行时若是遇到io，那就原地阻塞，仍然是没有解决遇到IO自动切换来提高效率的问题。

上面这个图，是协程真正的意义，虽然没有规避固有的I/O时间，可是咱们使用这个时间来作别的事情了， 通常在工做中咱们都是进程+线程+协程的方式来实现并发，以达到最好的并发效果， 若是是4核的cpu，通常起5个进程，每一个进程中20个线程（5倍cpu数量），每一个线程能够起500个协程， 大规模爬取页面的时候，等待网络延迟的时间的时候，咱们就能够用协程去实现并发。 并发数量 = 5 * 20 * 500 = 50000个并发，这是通常一个4cpu的机器最大的并发数。 nginx在负载均衡的时候最大承载量就是5w个 单线程里的这20个任务的代码一般会既有计算操做又有阻塞操做，咱们彻底能够在执行任务1时遇到阻塞， 就利用阻塞的时间去执行任务2。。。。如此，才能提升效率，这就用到了Gevent模块。 

Python

Copy

五、Gevent介绍

#安装
pip3 install gevent

　　Gevent 是一个第三方库，能够轻松经过gevent实现并发同步或异步编程，
在gevent中用到的主要模式是Greenlet,
它是以C扩展模块形式接入Python的轻量级协程。
Greenlet所有运行在主程序操做系统进程的内部，但它们被协做式地调度。

一、用法

g1=gevent.spawn(func,1,2,3,x=4,y=5)建立一个协程对象g1，spawn括号内第一个参数是函数名， 如eat，后面能够有多个参数，能够是位置实参或关键字实参，都是传给函数eat的，spawn是异步提交任务 g2=gevent.spawn(func2) g1.join() #等待g1结束，上面只是建立协程对象，这个join才是去执行;若是不写会由于主代码太快，而没有被执行 g2.join() #等待g2结束 有人测试的时候会发现，不写第二个join也能执行g2，是的，协程帮你切换执行了， 可是你会发现，若是g2里面的任务执行的时间长，可是不写join的话，就不会执行完等到g2剩下的任务了 #或者上述两步合做一步：gevent.joinall([g1,g2]) g1.value#拿到func1的返回值 

Python

Copy

二、gevent的简单使用

from gevent import monkey; monkey.patch_all() import time import gevent def func1(n): print("xxxxx", n) gevent.sleep(2) # time.sleep(2) # 没有使用monkey,模块不能识别其余io切换，monkey模块的做用是标记出来 print("eeeee", n) def func2(m): print("11111", m) gevent.sleep(2) # time.sleep(2) print("222222", m) start_time = time.time() g1 = gevent.spawn(func1, "李白") g2 = gevent.spawn(func2, "疏影") # g1.join() # g2.join() gevent.joinall([g1,g2]) # 实现了单线程的并发（线程里面的协程），节省了时间 end_time = time.time() print("运行时间", end_time - start_time) print("主任务结束") ```` #### 上例gevent.sleep(2)模拟的是gevent能够识别的io阻塞, 而time.sleep(2)或其余的阻塞,gevent是不能直接识别的须要用下面一行代码,打补丁,就能够识别了 from gevent import monkey;monkey.patch_all()必须放到被打补丁者的前面，如time，socket模块以前 能够直接理解为：必须放在最文件开头，才能标记后面的io阻塞 或者咱们干脆记忆成：要用gevent，须要将from gevent import monkey;monkey.patch_all()放到文件的开头 ```python 咱们能够用threading.current_thread().getName()来查看每一个g1和g2， 查看的结果为DummyThread-n，即假线程，虚拟线程，其实都在一个线程里面 进程线程的任务切换是由操做系统自行切换的，你本身不能控制 协程是经过本身的程序（代码）来进行切换的，本身可以控制， 只有遇到协程模块可以识别的IO操做的时候，程序才会进行任务切换， 实现并发效果，若是全部程序都没有IO操做，那么就基本属于串行执行了。 

Python

Copy

三、 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) if __name__ == '__main__': print('Synchronous:') synchronous() print('Asynchronous:') asynchronous() #上面程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。 初始化的greenlet列表存放在数组threads中，此数组被传给gevent.joinall 函数， 后者阻塞当前流程，并执行全部给定的greenlet。执行流程只会在 全部greenlet执行完后才会继续向下走。 

Python

Copy

四、Gevent之应用举例一

协程应用：爬虫

from gevent import monkey;monkey.patch_all() import gevent import requests import time def get_page(url): print('GET: %s' %url) response=requests.get(url) if response.status_code == 200: print('%d bytes received from %s' %(len(response.text),url)) start_time=time.time() gevent.joinall([ gevent.spawn(get_page,'https://www.python.org/'), gevent.spawn(get_page,'https://www.yahoo.com/'), gevent.spawn(get_page,'https://github.com/'), ]) stop_time=time.time() print('run time is %s' %(stop_time-start_time)) 

Python

Copy

将上面的程序最后加上一段串行的代码看看效率：
若是你的程序不须要过高的效率，那就不用什么并发啊协程啊之类的东西。

print('--------------------------------') s = time.time() requests.get('https://www.python.org/') requests.get('https://www.yahoo.com/') requests.get('https://github.com/') t = time.time() print('串行时间>>',t-s) 

Python

Copy

五、Gevent之应用举例二

经过gevent实现单线程下的socket并发（from gevent import monkey;monkey.patch_all()
必定要放到导入socket模块以前，不然gevent没法识别socket的阻塞）

一个网络请求里面通过多个时间延迟time

服务端

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) 

Python

Copy

客户端

from socket import * client=socket(AF_INET,SOCK_STREAM) client.connect(('127.0.0.1',8080)) while True: msg=input('>>: ').strip() if not msg:continue client.send(msg.encode('utf-8')) msg=client.recv(1024) 

Python

Copy

多线程并发多个客户端，去请求上面的服务端是没问题的

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() 多线程并发多个客户端，去请求上面的服务端是没问题的 

Python

Copy

2、IO多路复用

同步（synchronous） IO和异步（asynchronous） IO，阻塞（blocking） IO和非阻塞（non-blocking）IO分别是什么，
到底有什么区别？这个问题其实不一样的人给出的答案均可能不一样，
好比wiki，就认为asynchronous IO和non-blocking IO是一个东西。
这实际上是由于不一样的人的知识背景不一样，而且在讨论这个问题的时候上下文(context)也不相同。
因此，为了更好的回答这个问题，我先限定一下本文的上下文。

　　本文讨论的背景是Linux环境下的network IO。
本文最重要的参考文献是Richard Stevens的“UNIX® Network Programming Volume 1, Third Edition: The Sockets Networking ”，
6.2节“I/O Models ”，Stevens在这节中详细说明了各类IO的特色和区别，
若是英文够好的话，推荐直接阅读。
Stevens的文风是有名的深刻浅出，因此不用担忧看不懂。本文中的流程图也是截取自参考文献。

一、Stevens在文章中一共比较了五种IO Model：

* blocking IO          阻塞IO

　　* nonblocking IO 非阻塞IO
　　* IO multiplexing IO多路复用
　　* signal driven IO 信号驱动IO（不常见，不讲）
　　* asynchronous IO 异步IO
　　由signal driven IO（信号驱动IO）在实际中并不经常使用，因此主要介绍其他四种IO Model。

　　再说一下IO发生时涉及的对象和步骤。对于一个network IO (这里咱们以read、recv举例)，它会涉及到两个系统对象，一个是调用这个IO的process (or thread)，另外一个就是系统内核(kernel)。当一个read/recv读数据的操做发生时，该操做会经历两个阶段：

1）等待数据准备 (Waiting for the data to be ready)
2）将数据从内核拷贝到进程中(Copying the data from the kernel to the process)

　　记住这两点很重要，由于这些IO模型的区别就是在两个阶段上各有不一样的状况。

1.补充：

#一、输入操做：read、readv、recv、recvfrom、recvmsg共5个函数， 若是会阻塞状态，则会经理wait data和copy data两个阶段，若是设置为非阻塞则在wait 不到data时抛出异常 #二、输出操做：write、writev、send、sendto、sendmsg共5个函数， 在发送缓冲区满了会阻塞在原地，若是设置为非阻塞，则会抛出异常 #三、接收外来连接：accept，与输入操做相似 #四、发起外出连接：connect，与输出操做相似 

Python

Copy

二、阻塞IO(blocking IO)

就是咱们日常写的input,的代码，这样的阻塞
在linux中，默认状况下全部的socket都是blocking，
一个典型的读操做流程大概是这样：（recvfrom和tcp里面的recv在这些IO模型里面是同样的）

上面的图形分析：两个阶段的阻塞
因此，blocking IO的特色就是在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被block了。

　　这里咱们回顾一下同步/异步/阻塞/非阻塞：

　　　　同步：提交一个任务以后要等待这个任务执行完毕

　　　　异步：只管提交任务，不等待这个任务执行完毕就能够去作其余的事情

　　　　阻塞：recv、recvfrom、accept，线程阶段 运行状态–>阻塞状态–>就绪

　　　　非阻塞：没有阻塞状态

在一个线程的IO模型中，咱们recv的地方阻塞，咱们就开启多线程，
可是无论你开启多少个线程，这个recv的时间是否是没有被规避掉，
无论是多线程仍是多进程都没有规避掉这个IO时间。

三、非阻塞IO

Linux下，能够经过设置socket使其变为non-blocking。
当对一个non-blocking socket执行读操做时，流程是这个样子：

在非阻塞式IO中，用户进程实际上是须要不断的主动询问kernel数据准备好了没有。

虽然咱们上面的代码经过设置非阻塞，规避了IO操做，可是非阻塞IO模型毫不被推荐。

非阻塞IO模型服务端

import time import socket server = socket.socket() ip_port = ("127.0.0.1", 8001) server.bind(ip_port) server.listen() server.setblocking(False) # 设置不阻塞，把会阻塞的地方变得不阻塞，可是会报错，要用try捕获异常 conn_list = [] # 存放服务端对象，已经链接的管道对象 while 1: while 1: # 不停的轮询内核， try: conn,addr = server.accept() # 使用了setblocking后，这里不会阻塞，会有协程一直轮询内核， conn_list.append(conn) # 将 break except BlockingIOError: time.sleep(0.2) print("尚未接收到链接请求") print("你好") time.sleep(5) for sock in conn_list: print(sock) # 管道对象 while 1: try: from_cilent_msg = conn.recv(1024).decode("utf-8") print(from_cilent_msg) conn.send(b"hello") break except BlockingIOError: time.sleep(0.2) # while循环很耗内存，用sleep缓冲一下 print("没有接收到任何消息") 

Python

Copy

非阻塞IO模型客户端

import socket cilent = socket.socket() ip_port = ("127.0.0.1", 8001) cilent.connect(ip_port) cilent_msg = input("请输入消息>>>>") cilent.send(cilent_msg.encode("utf-8")) from_server_msg = cilent.recv(1024).decode("utf-8") print(from_server_msg) 

Python

Copy

非阻塞IO示例详细版

# 服务端 import socket import time server=socket.socket() server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) server.bind(('127.0.0.1',8083)) server.listen(5) server.setblocking(False) #设置不阻塞 r_list=[] #用来存储全部来请求server端的conn链接 w_list={} #用来存储全部已经有了请求数据的conn的请求数据 while 1: try: conn,addr=server.accept() #不阻塞，会报错 r_list.append(conn) #为了将链接保存起来，否则下次循环的时候，上一次的链接就没有了 except BlockingIOError: # 强调强调强调：！！！非阻塞IO的精髓在于彻底没有阻塞！！！ # time.sleep(0.5) # 打开该行注释纯属为了方便查看效果 print('在作其余的事情') print('rlist: ',len(r_list)) print('wlist: ',len(w_list)) # 遍历读列表，依次取出套接字读取内容 del_rlist=[] #用来存储删除的conn链接 for conn in r_list: try: data=conn.recv(1024) #不阻塞，会报错 if not data: #当一个客户端暴力关闭的时候，会一直接收b''，别忘了判断一下数据 conn.close() del_rlist.append(conn) continue w_list[conn]=data.upper() except BlockingIOError: # 没有收成功，则继续检索下一个套接字的接收 continue except ConnectionResetError: # 当前套接字出异常，则关闭，而后加入删除列表，等待被清除 conn.close() del_rlist.append(conn) # 遍历写列表，依次取出套接字发送内容 del_wlist=[] for conn,data in w_list.items(): try: conn.send(data) del_wlist.append(conn) except BlockingIOError: continue # 清理无用的套接字,无需再监听它们的IO操做 for conn in del_rlist: r_list.remove(conn) #del_rlist.clear() #清空列表中保存的已经删除的内容 for conn in del_wlist: w_list.pop(conn) #del_wlist.clear() #客户端 import socket import os import time import threading client=socket.socket() client.connect(('127.0.0.1',8083)) while 1: res=('%s hello' %os.getpid()).encode('utf-8') client.send(res) data=client.recv(1024) print(data.decode('utf-8')) ##多线程的客户端请求版本 # def func(): # sk = socket.socket() # sk.connect(('127.0.0.1',9000)) # sk.send(b'hello') # time.sleep(1) # print(sk.recv(1024)) # sk.close() # # for i in range(20): # threading.Thread(target=func).start() 

Python

Copy

1.非阻塞IO模型毫不被推荐

虽然咱们上面的代码经过设置非阻塞，规避了IO操做，可是非阻塞IO模型毫不被推荐。

　　咱们不可否则其优势：可以在等待任务完成的时间里干其余活了
（包括提交其余任务，也就是 “后台” 能够有多个任务在“”同时“”执行）。

2.可是也难掩其缺点：

1. 循环调用recv()将大幅度推高CPU占用率；
这也是咱们在代码中留一句time.sleep(2)的缘由,不然在低配主机下极容易出现卡机状况

2. 任务完成的响应延迟增大了，由于每过一段时间才去轮询一次read操做，
而任务可能在两次轮询之间的任意时间完成。这会致使总体数据吞吐量的下降。

此外，在这个方案中recv()更多的是起到检测“操做是否完成”的做用，
实际操做系统提供了更为高效的检测“操做是否完成“做用的接口，
例如select()多路复用模式，能够一次检测多个链接是否活跃。

四、多路复用IO(IO multiplexing)（重点）

先看解释图，里面的select就像个代理。

IO multiplexing这个词可能有点陌生，可是若是我说select/epoll，大概就都能明白了。
有些地方也称这种IO方式为事件驱动IO(event driven IO)。
咱们都知道，select/epoll的好处就在于单个process就能够同时处理多个网络链接的IO。
它的基本原理就是select/epoll这个function会不断的轮询所负责的全部socket，
当某个socket有数据到达了，就通知用户进程。它的流程如图：

1.强调：

1. 若是处理的链接数不是很高的话，使用select/epoll的web server不必定比使用multi-threading + blocking IO的web server性能更好，
可能延迟还更大。select/epoll的优点并非对于单个链接能处理得更快，而是在于能处理更多的链接。

2. 在多路复用模型中，对于每个socket，通常都设置成为non-blocking，可是，
如上图所示，整个用户的process实际上是一直被block的。
只不过process是被select这个函数block，而不是被socket IO给block。

2.python中的select模块：

import select fd_r_list, fd_w_list, fd_e_list = select.select(rlist, wlist, xlist, [timeout]) 参数： 可接受四个参数（前三个必须） rlist: wait until ready for reading #等待读的对象，你须要监听的须要获取数据的对象列表 wlist: wait until ready for writing #等待写的对象，你须要写一些内容的时候，input等等， 也就是说我会循环他看看是否有须要发送的消息，若是有我取出这个对象的消息并发送出去，通常用不到，这里咱们也给一个[]。 xlist: wait for an “exceptional condition” #等待异常的对象，一些额外的状况，通常用不到，可是必须传，那么咱们就给他一个[]。 timeout: 超时时间 当超时时间 ＝ n(正整数)时，那么若是监听的句柄均无任何变化，则select会阻塞n秒，以后返回三个空列表，若是监听的句柄有变化，则直接执行。 返回值：三个列表与上面的三个参数列表是对应的 　　select方法用来监视文件描述符(当文件描述符条件不知足时，select会阻塞)，当某个文件描述符状态改变后，会返回三个列表 一、当参数1 序列中的fd知足“可读”条件时，则获取发生变化的fd并添加到fd_r_list中 二、当参数2 序列中含有fd时，则将该序列中全部的fd添加到 fd_w_list中 三、当参数3 序列中的fd发生错误时，则将该发生错误的fd添加到 fd_e_list中 四、当超时时间为空，则select会一直阻塞，直到监听的句柄发生变化 

Python

Copy

三、结论:

select的优点在于能够处理多个链接，不适用于单个链接

fe1：io多路复用服务端、客户端示例

io多路复用服务端

import select import socket server = socket.socket() server.bind(('127.0.0.1',8001)) rlist = [server,] # 先将server对象放入列表，而后再将每一个通道对象放入 server.listen() while 1: print('11111') rl,wl,el = select.select(rlist,[],[]) # 每次会清空rl列表，从新监测 print(222222) print('server对象>>>',server) print(rl) for sock in rl: # 是server对象就添加通道对象，是通道，就行对应的收发消息 if sock == server: conn,addr = sock.accept() rlist.append(conn) else: from_client_msg = sock.recv(1024) print(from_client_msg.decode('utf-8')) # conn,addr = server.accept() # from_client_msg = conn.recv(1024) # print(from_client_msg.decode('utf-8')) 

Python

Copy

io多路复用客户端

import socket client = socket.socket() client.connect(('127.0.0.1',8001)) to_server_msg = input('发给服务端的消息:') client.send(to_server_msg.encode('utf-8')) # from_server_msg = client.recv(1024) # print(from_server_msg.decode('utf-8')) 

Python

Copy

select网络IO模型的示例代码详细解释版

#服务端 from socket import * import select server = socket(AF_INET, SOCK_STREAM) server.bind(('127.0.0.1',8093)) server.listen(5) # 设置为非阻塞 server.setblocking(False) # 初始化将服务端socket对象加入监听列表，后面还要动态添加一些conn链接对象，当accept的时候sk就有感应，当recv的时候conn就有动静 rlist=[server,] rdata = {} #存放客户端发送过来的消息 wlist=[] #等待写对象 wdata={} #存放要返回给客户端的消息 print('预备！监听！！！') count = 0 #写着计数用的，为了看实验效果用的，没用 while True: # 开始 select 监听,对rlist中的服务端server进行监听，select函数阻塞进程，直到rlist中的套接字被触发（在此例中，套接字接收到客户端发来的握手信号，从而变得可读，知足select函数的“可读”条件），被触发的（有动静的）套接字（服务器套接字）返回给了rl这个返回值里面； rl,wl,xl=select.select(rlist,wlist,[],0.5) print('%s 次数>>'%(count),wl) count = count + 1 # 对rl进行循环判断是否有客户端链接进来,当有客户端链接进来时select将触发 for sock in rl: # 判断当前触发的是否是socket对象, 当触发的对象是socket对象时,说明有新客户端accept链接进来了 if sock == server: # 接收客户端的链接, 获取客户端对象和客户端地址信息 conn,addr=sock.accept() #把新的客户端链接加入到监听列表中，当客户端的链接有接收消息的时候，select将被触发，会知道这个链接有动静，有消息，那么返回给rl这个返回值列表里面。 rlist.append(conn) else: # 因为客户端链接进来时socket接收客户端链接请求，将客户端链接加入到了监听列表中(rlist)，客户端发送消息的时候这个链接将触发 # 因此判断是不是客户端链接对象触发 try: data=sock.recv(1024) #没有数据的时候，咱们将这个链接关闭掉，并从监听列表中移除 if not data: sock.close() rlist.remove(sock) continue print("received {0} from client {1}".format(data.decode(), sock)) #将接受到的客户端的消息保存下来 rdata[sock] = data.decode() #将客户端链接对象和这个对象接收到的消息加工成返回消息，并添加到wdata这个字典里面 wdata[sock]=data.upper() #须要给这个客户端回复消息的时候，咱们将这个链接添加到wlist写监听列表中 wlist.append(sock) #若是这个链接出错了，客户端暴力断开了（注意，我尚未接收他的消息，或者接收他的消息的过程当中出错了） except Exception: #关闭这个链接 sock.close() #在监听列表中将他移除，由于无论什么缘由，它毕竟是断开了，不必再监听它了 rlist.remove(sock) # 若是如今没有客户端请求链接,也没有客户端发送消息时，开始对发送消息列表进行处理，是否须要发送消息 for sock in wl: sock.send(wdata[sock]) wlist.remove(sock) wdata.pop(sock) # #将一次select监听列表中有接收数据的conn对象所接收到的消息打印一下 # for k,v in rdata.items(): # print(k,'发来的消息是：',v) # #清空接收到的消息 # rdata.clear() --------------------------------------- #客户端 from socket import * client=socket(AF_INET,SOCK_STREAM) client.connect(('127.0.0.1',8093)) while True: msg=input('>>: ').strip() if not msg:continue client.send(msg.encode('utf-8')) data=client.recv(1024) print(data.decode('utf-8')) client.close() 

Python

Copy

四、select监听fd变化的过程分析：

用户进程建立socket对象，拷贝监听的fd到内核空间，每个fd会对应一张系统文件表，
内核空间的fd响应到数据后，就会发送信号给用户进程数据已到；

用户进程再发送系统调用，好比（accept）将内核空间的数据copy到用户空间，同时做为接受数据端内核空间的数据清除，
这样从新监听时fd再有新的数据又能够响应到了（发送端由于基于TCP协议因此须要收到应答后才会清除）。

五、该模型的优势：

相比其余模型，使用select() 的事件驱动模型只用单线程（进程）执行，占用资源少，不消耗太多 CPU，
同时可以为多客户端提供服务。若是试图创建一个简单的事件驱动的服务器程序，这个模型有必定的参考价值。

六、该模型的缺点：

首先select()接口并非实现“事件驱动”的最好选择。由于当须要探测的句柄值较大时，
select()接口自己须要消耗大量时间去轮询各个句柄。不少操做系统提供了更为高效的接口，
如linux提供了epoll，BSD提供了kqueue，Solaris提供了/dev/poll，…。若是须要实现更高效的服务器程序，
相似epoll这样的接口更被推荐。遗憾的是不一样的操做系统特供的epoll接口有很大差别，
因此使用相似于epoll的接口实现具备较好跨平台能力的服务器会比较困难。

其次，该模型将事件探测和事件响应夹杂在一块儿，一旦事件响应的执行体庞大，则对整个模型是灾难性的。

七、IO多路复用的机制：

Select  将全部须要监听的对象,放到一个列表里面,将这个列表交给select来监听,
凡有动静的对象,直接给你返回到一个列表中,而后咱们循环这个列表,根据列表里面的有动静的对象,来进行对应的操做.  window 和 linux

Poll  : 监听的对象数量没有上限,而select默认是1024个,Linux
    Select和poll内部在监听的全部对象的时候,是循环遍历的操做,挨个问一遍有没有数据

Epoll : linux,每一个被监听的对象,都是经过回调机制来搞的,
也就是,监听的列表对象里面的这个对象,凡有动静,自行通知epoll,而后epoll把这些有动静的对象返回.

五、异步IO(Asynchronous I/O)

最NB的,效率最高,由于将网络请求里面的两个io时间都省了