python并发编程之IO模型

#所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不会返回。按照这个定义，
其实绝大多数函数都是同步调用。但是一般而言，我们在说同步、异步的时候，
特指那些需要其他部件协作或者需要一定时间完成的任务。
#举例：
#1. multiprocessing.Pool下的apply #发起同步调用后，就在原地等着任务结束，
根本不考虑任务是在计算还是在io阻塞，总之就是一股脑地等任务结束
#2. concurrent.futures.ProcessPoolExecutor().submit(func,).result()
#3. concurrent.futures.ThreadPoolExecutor().submit(func,).result()

#异步的概念和同步相对。当一个异步功能调用发出后，调用者不能立刻得到结果。
当该异步功能完成后，通过状态、通知或回调来通知调用者。如果异步功能用状态来通知，
那么调用者就需要每隔一定时间检查一次，效率就很低（有些初学多线程编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一 种很严重的错误）。
如果是使用通知的方式，效率则很高，因为异步功能几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。
#举例：
#1. multiprocessing.Pool().apply_async() #发起异步调用后，并不会等待任务结束才返回，相反，
会立即获取一个临时结果（并不是最终的结果，可能是封装好的一个对象）。
#2. concurrent.futures.ProcessPoolExecutor(3).submit(func,)
#3. concurrent.futures.ThreadPoolExecutor(3).submit(func,)

#阻塞调用是指调用结果返回之前，当前线程会被挂起（如遇到io操作）。函数只有在得到结果之后才会
将阻塞的线程激活。有人也许会把阻塞调用和同步调用等同起来，实际上他是不同的。对于同步调用来说，
很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已。
#举例：
#1. 同步调用：apply一个累计1亿次的任务，该调用会一直等待，直到任务返回结果为止，
但并未阻塞住（即便是被抢走cpu的执行权限，那也是处于就绪态）;
#2. 阻塞调用：当socket工作在阻塞模式的时候，如果没有数据的情况下调用recv函数，
则当前线程就会被挂起，直到有数据为止。

#在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每个连接都拥有独立的线程（或进程），
这样任何一个连接的阻塞都不会影响其他的连接。

#开启多进程或都线程的方式，在遇到要同时响应成百上千路的连接请求，
则无论多线程还是多进程都会严重占据系统资源，降低系统对外界响应效率，
而且线程与进程本身也更容易进入假死状态。

很多程序员可能会考虑使用“线程池”或“连接池”。
“线程池”旨在减少创建和销毁线程的频率，其维持一定合理数量的线程，并让空闲的线程重新承担新的执行任务
。“连接池”维持连接的缓存池，尽量重用已有的连接、减少创建和关闭连接的频率。这两种技术都可以很好
的降低系统开销，都被广泛应用很多大型系统，如websphere、tomcat和各种数据库等。

#“线程池”和“连接池”技术也只是在一定程度上缓解了频繁调用IO接口带来的资源占用。而且，
所谓“池”始终有其上限，当请求大大超过上限时，“池”构成的系统对外界的响应并不比没有池的时候效果
好多少。所以使用“池”必须考虑其面临的响应规模，并根据响应规模调整“池”的大小。

server.setblocking()#默认是True  

server.setblocking(False) #False的话就成非阻塞了，这只是对于socket套接字来说的 

所以，在非阻塞式IO中，用户进程其实是需要不断的主动询问内核数据准备好了没有。

wait data 等数据的这个阶段是不阻塞的 
copy data 这个阶段还是要阻塞的

 1 #这种程序虽说解决了单线程并发，但是大大的占用了cpu
 2 from socket import *
 3 import time
 4 severt = socket(AF_INET,SOCK_STREAM)
 5 severt.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
 6 severt.bind((‘127.0.0.1‘,8080))
 7 severt.listen(5)
 8 severt.setblocking(False) #默认是True  (如果是False,套接字里的一些阻塞操作都变成非阻塞的)
 9 print(‘startting....‘)
10 conn_l = []
11 del_l =[]
12 while True:
13     try:
14         print(conn_l)
15         conn,addr = severt.accept() #收不到数据的时候才出异常
16         print(conn)
17         conn_l.append(conn)
18     except BlockingIOError:  #吧收不到数据的那段时间利用起来（利用他收不到
19         #数据的时候，才干下面的for循环）
20        for conn in conn_l:
21             try:
22                 data = conn.recv(1024)
23                 conn.send(data.upper())
24             except BlockingIOError:
25                 pass
26             except ConnectionResetError:  #端开链接的错误（如果突然断开链接，会报错
27                                            #就先添加到列表里面去，完了吧链接给清除了）
28                  del_l.append(conn)
29        for obj in del_l:
30              obj.close()
31              conn_l.remove(obj)
32        del_l.clear()

1 from socket import *
2 client = socket(AF_INET,SOCK_STREAM)
3 client.connect((‘127.0.0.1‘,8080))
4 while True:
5     cmd = input(‘>>:‘).strip()
6     if not cmd:continue
7     client.send(cmd.encode(‘utf-8‘))
8     data = client.recv(1024)
9     print(data.decode(‘utf-8‘))

#用户进程创建socket对象，拷贝监听的fd到内核空间，每一个fd会对应一张系统文件表，
内核空间的fd响应到数据后，就会发送信号给用户进程数据已到；
#用户进程再发送系统调用，比如（accept）将内核空间的数据copy到用户空间，
同时作为接受数据端内核空间的数据清除，这样重新监听时fd再有新的数据又可以响应到了
（发送端因为基于TCP协议所以需要收到应答后才会清除）。

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

#首先select()接口并不是实现“事件驱动”的最好选择。因为当需要探测的句柄值较大时，
select()接口本身需要消耗大量时间去轮询各个句柄。很多操作系统提供了更为高效的接口，
如linux提供了epoll，BSD提供了kqueue，Solaris提供了/dev/poll，…。
如果需要实现更高效的服务器程序，类似epoll这样的接口更被推荐。
遗憾的是不同的操作系统特供的epoll接口有很大差异，所以使用类似于epoll的接口实现
具有较好跨平台能力的服务器会比较困难。
#其次，该模型将事件探测和事件响应夹杂在一起，一旦事件响应的执行体庞大，则对整个模型是灾难性的。