IO多路复用前需了解
通常，我们写服务器处理模型的程序时，有以下几种模型：
（1）每收到一个请求，创建一个新的进程，来处理该请求；
（2）每收到一个请求，创建一个新的线程，来处理该请求；
（3）每收到一个请求，放入一个事件列表，让主进程通过非阻塞I/O方式来处理请求
上面的几种方式，各有千秋，
第（1）中方法，由于创建新的进程的开销比较大，所以，会导致服务器性能比较差,但实现比较简单。
第（2）种方式，由于要涉及到线程的同步，有可能会面临死锁等问题。
第（3）种方式，在写应用程序代码时，逻辑比前面两种都复杂。
综合考虑各方面因素，一般普遍认为第（3）种方式是大多数网络服务器采用的方式
在UI编程中，常常要对鼠标点击进行相应，首先如何获得鼠标点击呢？
方式一：创建一个线程，该线程一直循环检测是否有鼠标点击，那么这个方式有以下几个缺点：
1. CPU资源浪费，可能鼠标点击的频率非常小，但是扫描线程还是会一直循环检测，这会造成很多的CPU资源浪费；如果扫描鼠标点击的接口是阻塞的呢？
2. 如果是堵塞的，又会出现下面这样的问题，如果我们不但要扫描鼠标点击，还要扫描键盘是否按下，由于扫描鼠标时被堵塞了，那么可能永远不会去扫描键盘；
3. 如果一个循环需要扫描的设备非常多，这又会引来响应时间的问题；
所以，该方式是非常不好的。
目前大部分的UI编程都是事件驱动模型，如很多UI平台都会提供onClick()事件，这个事件就代表鼠标按下事件。事件驱动模型大体思路如下：
1. 有一个事件（消息）队列；
2. 鼠标按下时，往这个队列中增加一个点击事件（消息）；
3. 有个循环，不断从队列取出事件，根据不同的事件，调用不同的函数，如onClick()、onKeyDown()等；
4. 事件（消息）一般都各自保存各自的处理函数指针，这样，每个消息都有独立的处理函数
事件驱动编程是一种编程范式，这里程序的执行流由外部事件来决定。它的特点是包含一个事件循环，当外部事件发生时使用回调机制来触发相应的处理。另外两种常见的编程范式是（单线程）同步以及多线程编程。
协程处理：简单理解
一遇到IO就切换，IO操作是有操作系统完成的，Python通过调度操作系统的文件接口进行IO操作.
得到结论:IO操作是操作系统负责完成的
问题是什么时候确认操作系统已经完成了IO操作 我可以切换回去？
只要加一个回调函数，告诉操作系统，如果你处理完了以后就调下回调函数，回调函数就会通知我。接到通知我自然就知道你已经操作完了，然后切换回去获取数据
同步IO和异步IO，阻塞IO和非阻塞IO分别是什么，到底有什么区别？不同的人在不同的上下文下给出的答案是不同的。所以先限定一下本文的上下文
一 概念说明
在进行解释之前，首先要说明几个概念：
- 用户空间和内核空间
32位的Linux来说，默认把内存划分1G给内核用（内核空间），而3G给各个进程用（用户空间）
- 进程切换
内核可以挂起CPU正在运行的进程，也可以进行恢复挂起的进程（称之进程切换）
- 进程的阻塞
期待的某些事未发送，如请求系统资源失败、等待某种操作完成、新数据未到达等等就会转换成阻塞状态，不暂用CPU资源
- 文件描述符
索引值，内核为每个进程所维护的该进程打开文件的记录表，简单理解程序打开一个现有的文件和创建一个新的文件，内核会向该程序返回一个文件描述符
- 缓存 I/O
缓存 I/O 又被称作标准 I/O，大多数文件系统的默认 I/O 操作都是缓存 I/O。在 Linux 的缓存 I/O 机制中，操作系统会将 I/O 的数据缓存在文件系统的页缓存（ page cache ）中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。
缓存 I/O 的缺点：
数据在传输过程中需要在应用程序地址空间和内核进行多次数据拷贝操作，这些数据拷贝操作所带来的 CPU 以及内存开销是非常大的。
IO模式
刚才说了，对于一次IO访问（以read举例），数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。所以说，当一个read操作发生时，它会经历两个阶段：
1. 等待数据准备 (Waiting for the data to be ready)
2. 将数据从内核拷贝到进程中 (Copying the data from the kernel to the process)
正式因为这两个阶段，linux系统产生了下面五种网络模式的方案：
- 阻塞 I/O（blocking IO）
请求发去以后，kernel开始准备数据（把硬盘的数据拷贝到内核缓存区），此刻进程
入阻塞block状态，，等到kernel把数据拷贝到了用户内存（用户空间），然后返回一个结果给进程，进程才解除block状态
- 非阻塞 I/O（nonblocking IO）
请求以后，kernel直接返回一个错误，进程自然正常，我们可以进行循环检测该请求直到kernal准备好为止
- I/O 多路复用（ IO multiplexing）
elect，poll，epoll都是IO多路复用的机制。I/O多路复用就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作
它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程
所以，如果处理的连接数不是很高的话，使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。）
非阻塞socket +select（epoll）==对于使用者来说就是所谓的异步I/O， 开发者角度还是同步
- 信号驱动 I/O（ signal driven IO）
由于signal driven IO在实际中并不常用，所以我这只提及剩下的四种IO Model。
- 异步 I/O（asynchronous IO）
用的很少，很多漏洞
首先列一下，sellect、poll、epoll三者的区别
select
select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。
select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点，事实上从现在看来，这也是它所剩不多的优点之一。
select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。
另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。
poll
poll在1986年诞生于System V Release 3，它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。
poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。
另外，select()和poll()将就绪的文件描述符告诉进程后，如果进程没有对其进行IO操作，那么下次调用select()和poll()的时候将再次报告这些文件描述符，所以它们一般不会丢失就绪的消息，这种方式称为水平触发（Level Triggered）。
epoll
直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。
epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。
epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。
另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。
epoll(市场用的最多，如果单单连接不做任何事 1G内核内存可以支持10W连接)
市面上所谓的异步IO ：Nginx tornado twisted 只是称之，其实真正是采用IO多路复用
Python select
Python的select()方法直接调用操作系统的IO接口，它监控sockets,open files, and pipes(所有带fileno()方法的文件句柄)何时变成readable 和writeable, 或者通信错误，select()使得同时监控多个连接变的简单，并且这比写一个长循环来等待和监控多客户端连接要高效，因为select直接通过操作系统提供的C的网络接口进行操作，而不是通过Python的解释器。
注意：Using Python’s file objects with select() works for Unix, but is not supported under Windows.
接下来通过echo server例子要以了解select 是如何通过单进程实现同时处理多个非阻塞的socket连接的
使用select需要非阻塞IO情况下才可以使用
select实战服务端：
__author__ = "Burgess Zheng"
import select
import socket
import queue
server = socket.socket()
server.setblocking(0)
server_addr = ('localhost',10000)
print('starting up on %s port %s' % server_addr)
server.bind(server_addr) #设置非阻塞模式
server.listen(5)
inputs = [server, ] #自己也要监测呀,因为server本身也是个fd
#server就是本身的连接，在没有连接过来的时候select是检测该server本身连接
#如果发现server有活动代表有客户端连接进来
outputs = []#输出空列表
message_queues = {}#定义个一个空字典，接收客户端的数据
while True:
print("waiting for next event...")
readable, writeable, exeptional = select.select(inputs,outputs,inputs) #如果没有任何fd就绪,那程序就会一直阻塞在这里
for s in readable: #每个s就是一个socket(#客户端连接过来的实例)
if s is server: #别忘记,上面我们server自己也当做一个fd放在了inputs列表里,传给了select,如果这个s是server,代表server这个fd就绪了,
#就是有活动了, 什么情况下它才有活动? 当然 是有新连接进来的时候 呀
#新连接进来了,接受这个连接
conn, client_addr = s.accept()#接收客户端的数据，conn：链接标记 addr：对面地址
print("new connection from",client_addr)
conn.setblocking(0)
inputs.append(conn) #为了不阻塞整个程序,我们不会立刻在这里开始接收客户端发来的数据, 把它放到inputs里, 下一次loop时,这个新连接
#就会被交给select去监听,如果这个连接的客户端发来了数据 ,那这个连接的fd在server端就会变成就续的,select就会把这个连接返回,返回到
#readable 列表里,然后你就可以loop readable列表,取出这个连接,开始接收数据了, 下面就是这么干 的
message_queues[conn] = queue.Queue() #接收到客户端的数据后,不立刻返回 ,暂存在队列里,以后发送
else: #s不是server的话,那就只能是一个 与客户端建立的连接的fd了
#客户端的数据过来了,在这接收
data = s.recv(1024)
if data:
print("收到来自[%s]的数据:" % s.getpeername()[0], data)
message_queues[s].put(data) #收到的数据先放到queue里,一会返回给客户端
if s not in outputs:
outputs.append(s) #为了不影响处理与其它客户端的连接 , 这里不立刻返回数据给客户端
else:#如果收不到data代表什么呢? 代表客户端断开了呀
print("客户端断开了",s)
if s in outputs:
outputs.remove(s) #清理已断开的连接
inputs.remove(s) #清理已断开的连接
del message_queues[s] ##清理已断开的连接
for s in writeable:
try :
next_msg = message_queues[s].get_nowait()
except queue.Empty:
print("client [%s]" %s.getpeername()[0], "queue is empty..")
outputs.remove(s)
else:
print("sending msg to [%s]"%s.getpeername()[0], next_msg)
s.send(next_msg.upper())
for s in exeptional:#出现连接异常
print("handling exception for ",s.getpeername())
inputs.remove(s)#检测列表移除掉该异常
if s in outputs:#如果返回列表有该连接移除掉
outputs.remove(s)#移除掉字典该连接数据
s.close()
del message_queues[s]
客户端1
#_*_coding:utf-8_*_
__author__ = "Burgess Zheng"
import socket
import sys
messages = [ b'This is the message. ',
b'It will be sent ',
b'in parts.',
]
server_address = ('localhost', 10000)
# Create a TCP/IP socket
socks = [ socket.socket(socket.AF_INET, socket.SOCK_STREAM),
socket.socket(socket.AF_INET, socket.SOCK_STREAM),
]
# Connect the socket to the port where the server is listening
print('connecting to %s port %s' % server_address)
for s in socks:
s.connect(server_address)
for message in messages:
# Send messages on both sockets
for s in socks:
print('%s: sending "%s"' % (s.getsockname(), message) )
s.send(message)
# Read responses on both sockets
for s in socks:
data = s.recv(1024)
print( '%s: received "%s"' % (s.getsockname(), data) )
if not data:
print(sys.stderr, 'closing socket', s.getsockname() )
客户端2
#_*_coding:utf-8_*_
__author__ = "Burgess Zheng"
import socket
HOST = 'localhost' # The remote host
PORT = 10000 # The same port as used by the server
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
while True:
msg = bytes(input(">>:"), encoding="utf8")
s.sendall(msg)
data = s.recv(1024)
print('Received', data)
s.close()
执行结果
Python的selectors模块
selectors模块
This module allows high-level and efficient I/O multiplexing, built upon the select module primitives. Users are encouraged to use this module instead, unless they want precise control over the OS-level primitives used.
这个模块允许高层和高效的I / O多路复用,建立在原语的选择模块。鼓励用户使用这个模块相反,除非他们想要精确控制所使用的操作系统原语。
selectors模块就是封装了select 和epole多路复用IO
window不能支持epole模式，所以默认是select模式
linux默认是epole模式
试验selectors(然后开启1000个socket客户端访问server端)
server
import selectors
import socket
#Linux默认封装是epole window不支持epole所以默认是select
sel = selectors.DefaultSelector()#生成一个selector对象
def accept(sock,mask):#mask连接数量（当前多少个客户端连接）
conn, addr = sock.accept() # conn：链接标记位,addr：对方的地址
print('accepted', conn, 'from', addr)
conn.setblocking(False)#把该链接设置为非阻塞IO模式
sel.register(conn, selectors.EVENT_READ, read)
#把该客户端的conn链接标记位注册到sel#让sel监听
#如果该连接再次活动就调用read该函数（往while循环看）
def read(conn, mask):
data = conn.recv(1000) #接收数据
if data:#如果有数据
print('echoing', repr(data), 'to', conn)
conn.send(data) # 返回数据
else:
print('closing', conn)#该连接断开了
sel.unregister(conn)#取消注册
conn.close()#关闭该连接
sock = socket.socket()#生成socket
sock.bind(('localhost', 10000))#绑定端口
sock.listen(100)#最多并发100
sock.setblocking(False)#设置非阻塞IO模式
sel.register(sock, selectors.EVENT_READ, accept)
#server对象sock注册到sel#让sel监听
#第一次客户端连接的时候经过下面的while True
#如果是新连接经过了while True判断以后会调用accept函数
while True:
events = sel.select() #默认阻塞，有活动连接就返回活动的连接列表
for key, mask in events:
# events相当于sel监听的连接列表（里面目前监听sock本服务器的连接）
# 由于server连接活动代表新的客户连接进来了
# 新连接的客户端信息返回值放入key
# key =客户端发起访问连接的信息
callback = key.data # callback = key.data = 调取accept函数
callback(key.fileobj, mask)
#key.fileobj =文件句柄==还没有建立连接的客户端信息
# accept(key.fileobj,mask) key.xx：实参 mask：实参
client（开启100个socket连接服务端）
__author__ = "Burgess Zheng"
import socket
import sys
messages = [ b'This is the message. ',
b'It will be sent ',
b'in parts.',
]
server_address = ('localhost', 10000)
# Create a TCP/IP socket
socks = [ socket.socket(socket.AF_INET, socket.SOCK_STREAM) for i in range(100)]
#开启100个socket
print(socks)
# Connect the socket to the port where the server is listening
print('connecting to %s port %s' % server_address)
for s in socks:
s.connect(server_address)
for message in messages:
# Send messages on both sockets
for s in socks:
print('%s: sending "%s"' % (s.getsockname(), message) )
s.send(message)
# Read responses on both sockets
for s in socks:
data = s.recv(1024)
print( '%s: received "%s"' % (s.getsockname(), data) )
if not data:
print( 'closing socket', s.getsockname() )
执行结果：
