1.事件驱动模型
上一篇写的协程仅仅是切换,本身不能实现并发，什么时候切换也不知道
那么什么时候切回去呢？怎么确定IO操作完了？通过回调函数
对于事件驱动型程序模型，它的流程大致如下： 开始--->初始化--->等待
事件驱动程序在启动之后，就在那等待，等待什么呢？等待被事件触发。传统编程下也有“等待”的时候，比如在代码块D中，你定义了一个input()，需要用户输入数据。但这与下面的等待不同，传统编程的“等待”，比如input()，你作为程序编写者是知道或者强制用户输入某个东西的，或许是数字，或许是文件名称，如果用户输入错误，你还需要提醒他，并请他重新输入。事件驱动程序的等待则是完全不知道，也不强制用户输入或者干什么。只要某一事件发生，那程序就会做出相应的“反应”。这些事件包括：输入信息、鼠标、敲击键盘上某个键还有系统内部定时器触发。
在事件驱动版本的程序中，3个任务交错执行，但仍然在一个单独的线程控制中。当处理I/O或者其他昂贵的操作时，注册一个回调到事件循环中，然后当I/O操作完成时继续执行。回调描述了该如何处理某个事件。事件循环轮询所有的事件，当事件到来时将它们分配给等待处理事件的回调函数。这种方式让程序尽可能的得以执行而不需要用到额外的线程。事件驱动型程序比多线程程序更容易推断出行为，因为程序员不需要关心线程安全问题。
当我们面对如下的环境时，事件驱动模型通常是一个好的选择：
程序中有许多任务，而且…
任务之间高度独立（因此它们不需要互相通信，或者等待彼此）而且…
在等待事件到来时，某些任务会阻塞。
事件驱动只不过是框架规定了执行顺序，程序员在使用框架时，可以向原执行顺序中注册“事件”，从而在框架执行时可以出发已注册的“事件”。
2.IO多路复用
如何去实现事件驱动的情况下IO的自动阻塞的切换，这个学名叫什么呢？ => IO多路复用
比如socketserver，多个客户端连接，单线程下实现并发效果，就叫多路复用。
比如socketserver，多个客户端连接，单线程下实现并发效果，就叫多路复用。
多路复用是指使用一个线程来检查多个文件描述符（Socket）的就绪状态，比如调用select和poll函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回，否则阻塞直到超时。得到就绪状态后进行真正的操作可以在同一个线程里执行，也可以启动线程执行（比如使用线程池）。
文件描述符（File descriptor）是计算机科学中的一个术语，是一个用于表述指向文件的引用的抽象化概念。
文件描述符在形式上是一个非负整数。实际上，它是一个索引值，指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符。在程序设计中，一些涉及底层的程序编写往往会围绕着文件描述符展开。但是文件描述符这一概念往往只适用于UNIX、Linux这样的操作系统。
这样在处理1000个连接时，只需要1个线程监控就绪状态，对就绪的每个连接开一个线程处理就可以了，这样需要的线程数大大减少，减少了内存开销和上下文切换的CPU开销。
I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。
# 在linux的IO多路复用中有水平触发,边缘触发两种模式,这两种模式的区别如下:
#
# 水平触发:如果文件描述符已经就绪可以非阻塞的执行IO操作了,此时会触发通知.允许在任意时刻重复检测IO的状态,
# 没有必要每次描述符就绪后尽可能多的执行IO.select,poll就属于水平触发.
#
# 边缘触发:如果文件描述符自上次状态改变后有新的IO活动到来,此时会触发通知.在收到一个IO事件通知后要尽可能
# 多的执行IO操作,因为如果在一次通知中没有执行完IO那么就需要等到下一次新的IO活动到来才能获取到就绪的描述
# 符.信号驱动式IO就属于边缘触发.
select调用是内核级别的，select轮询相对非阻塞的轮询的区别在于—前者可以等待多个socket，能实现同时对多个IO端口进行监听，当其中任何一个socket的数据准好了，就能返回进行可读，然后进程再进行recvfrom系统调用，将数据由内核拷贝到用户进程，当然这个过程是阻塞的。
server端
#__author: greg
#date: 2017/9/24 21:52
import socket sk1=socket.socket()
sk1.bind(('127.0.0.1',8001))
sk1.listen() sk2=socket.socket()
sk2.bind(('127.0.0.1',8002))
sk2.listen() sk3=socket.socket()
sk3.bind(('127.0.0.1',8003))
sk3.listen() # inputs=[sk1,sk2,sk3,]
inputs=[sk1,] import select
while True:
# [sk1, sk2,sk3,],select内部自动监听sk1，sk2，sk3三个对象，一旦某个句柄发生变化
# 如果有人链接sk1
# r_list=[sk1] #如果有人第一次连接，，sk1发生变化
#句柄列表11, 句柄列表22, 句柄列表33 = select.select(句柄序列1, 句柄序列2, 句柄序列3, 超时时间)
r_list,w_list,e_list=select.select(inputs,[],[],1)
print(r_list)
for sk in r_list:
#conn每一个连接对象
conn,address=sk.accept()
conn.sendall(bytes('hello',encoding='utf8'))
conn.close() # while True:
# conn, address = sk.accept()
# while True:
# content_bytes=conn.recv(1024)
# content_str=str(content_bytes,encoding='utf8')
# conn.sendall(bytes(content_bytes+'好',encoding='utf8'))#sendall就是用while循环调用send
# conn.close()
client端
#__author: greg
#date: 2017/9/24 22:30
import socket obj=socket.socket()
obj.connect(('127.0.0.1',8001))
content=str(obj.recv(1024),encoding='utf8')
print(content)
obj.close()
实例，并发聊天
sk=socket.socket()
sk.bind(("127.0.0.1",8801))
sk.listen(5)
inputs=[sk,]
while True:
r,w,e=select.select(inputs,[],[],5)
print(len(r)) for obj in r:
if obj==sk:
conn,add=obj.accept()
print(conn)
#[<socket.socket fd=420, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8801), raddr=('127.0.0.1', 55504)>]
inputs.append(conn)
else:
data_byte=obj.recv(1024)
print(str(data_byte,'utf8'))
inp=input('回答%s号客户>>>'%inputs.index(obj))
obj.sendall(bytes(inp,'utf8')) print('>>',r)
文件描述符其实就是咱们平时说的句柄，只不过文件描述符是linux中的概念。注意，我们的accept或recv调用时即向系统发出recvfrom请求
(1) 如果内核缓冲区没有数据－－－>等待－－－>数据到了内核缓冲区，转到用户进程缓冲区；
(2) 如果先用select监听到某个文件描述符对应的内核缓冲区有了数据，当我们再调用accept或recv时，直接将数据转到用户缓冲区。
如何在某一个client端退出后，不影响server端和其它客户端正常交流
try:
data_byte=obj.recv(1024)
print(str(data_byte,'utf8'))
inp=input('回答%s号客户>>>'%inputs.index(obj))
obj.sendall(bytes(inp,'utf8'))
except Exception:
inputs.remove(obj)
select.seclect的四个参数
select(rlist, wlist, xlist[, timeout]) -> (rlist, wlist, xlist)
Wait until one or more file descriptors are ready for some kind of I/O.
The first three arguments are sequences of file descriptors to be waited for:
rlist -- wait until ready for reading
wlist -- wait until ready for writing
xlist -- wait for an ``exceptional condition''
If only one kind of condition is required, pass [] for the other lists.
A file descriptor is either a socket or file object, or a small integer
gotten from a fileno() method call on one of those.
The optional 4th argument specifies a timeout in seconds; it may be
a floating point number to specify fractions of seconds. If it is absent
or None, the call will never time out.
The return value is a tuple of three lists corresponding to the first three
arguments; each contains the subset of the corresponding file descriptors
that are ready.
等待一个或多个文件描述符准备好进行某种I / O操作。前三个参数是等待文件描述符的序列：
rlist - 等待直到准备好阅读
wlist - 等待，直到准备好写作
xlist - 等待一个“例外条件”
如果只需要一种条件，则为其他列表传递[]。 文件描述符可以是套接字或文件对象，也可以是其中一个fileno（）方法调用获得的小整数。可选的第四个参数指定以秒为单位的超时时间; 它可能是一个浮点数来指定几分之一秒。 如果不存在或无，则调用永远不会超时。返回值是与前三个参数对应的三个列表的元组; 每个都包含准备好的相应文件描述符的子集。
server端
#__author: greg
#date: 2017/9/24 22:58
import socket
import select sk1=socket.socket()
sk1.bind(('127.0.0.1',8001))
sk1.listen() # inputs=[sk1,sk2,sk3,]
inputs=[sk1,]
outputs=[] message_dict={} while True:
# [sk1, sk2,sk3,],select内部自动监听sk1，sk2，sk3三个对象，一旦某个句柄发生变化
# 如果有人链接sk1
# r_list=[sk1] #如果有人第一次连接，，sk1发生变化 # select内部自动监听socket对象，一旦socket变换感知到
r_list,w_list,e_list=select.select(inputs,outputs,inputs,1)
print('正在监听的socket对象%d'%len(inputs))
print(r_list)
for sk_or_conn in r_list:
#conn每一个连接对象
if sk_or_conn==sk1:
#表示有新用户来连接
conn,address=sk_or_conn.accept()
inputs.append(conn)
message_dict[conn]=[]
else:
#有老用户发消息
try:
data_bytes=sk_or_conn.recv(1024)
# data_str=str(data_bytes,encoding='utf8')
# sk_or_conn.sendall(bytes(data_str+'好',encoding='utf8'))
except Exception as e:
inputs.remove(sk_or_conn)
else:
#用户正常发送消息
data_str=str(data_bytes,encoding='utf8')
print(data_str)
# sk_or_conn.sendall(bytes(data_str+'好',encoding='utf8'))
message_dict[sk_or_conn].append(data_str)
outputs.append(sk_or_conn) #w_list仅仅保存了谁给我发过消息
for conn in w_list:
recv_str=message_dict[conn][0]
del message_dict[conn][0]
conn.sendall(bytes(recv_str+'好',encoding='utf8'))
outputs.remove(conn)
for sk in e_list:
inputs.remove(sk)
客户端
#__author: greg
#date: 2017/9/24 22:20
import socket obj=socket.socket()
obj.connect(('127.0.0.1',8001))
# content=str(obj.recv(1024),encoding='utf8')
# print(content)
while True:
inp=input('>>>')
obj.sendall(bytes(inp,encoding='utf8'))
ret=str(obj.recv(1024),encoding='utf8')
print(ret)
obj.close()