IO模型实际应用与协程

概述前言 本章主要针对上一章节中的I/O模型做一些代码性的练习，尽管可能很少用到。但是你应当知道这些东西。还是具体结合上一篇的理论知识来看吧。最后将协程放在了扩展篇中，因为感觉目前能接触到的很多都是I/O 前言

　　本章主要针对上一章节中的I/O模型做一些代码性的练习，尽管可能很少用到。但是你应当知道这些东西。还是具体结合上一篇的理论知识来看吧。最后将协程放在了扩展篇中，因为感觉目前能接触到的很多都是I/O多路复用+异步。协程属实不太常见，可能我层次低了。

阻塞I/O的socket服务端

　　阻塞点1：accept()等待三次握手建立链接

　　阻塞点2：recv()从内核态的缓冲区复制数据到用户态内存

#!/usr/bin/env @R_404_4729@# -*- Coding:utf-8 -*-import socketserver = socket.socket(family=socket.AF_INET,type=socket.soCK_STREAM)server.bind(("127.0.0.1",6666)) server.Listen(5)while 1:    conn,clIEnt_addr = server.accept()   阻塞点 1    :        try:             data = conn.recv(1024)   阻塞点 2            if not data:                break            conn.send(data.upper())        except ConnectionresetError as e:            print(clIEnt_addr,关闭了双向链接")                conn.close()

非阻塞I/O的socket服务端

　　阻塞点1：recv()从内核态的缓冲区复制数据到用户态内存

socket.soCK_STREAM)server.setblocking(False)   设置为非阻塞server.bind(())server.Listen(5:    :        conn,1)"> 不阻塞    except BlockingIOError as e:   捕捉异常        continue    :            data = conn.recv(1024)   读取数据时依然会阻塞            break         捕捉异常            continue    conn.close()

select模块与I/O多路复用

　　阻塞点1：即描述符监听r_List，如果有事件触发就放到r列表中

　　阻塞点2：recv()从内核态的缓冲区复制数据到用户态内存

 socket selectserver = socket.socket(family=socket.AF_INET,1)">)r_List = [server,]   被监听的socket对象，读取事件w_List = []   被监听的socket对象，写入事件:    r,w,e = select.select(r_List,w_List,[],0.5)    """    r:   相当于一个空列表，当被监听的r_List中有任何对象能够读取数据了，则放到 r 列表中。    w:   同上，放的是可写的    e：   同上，放的是错误的    0.5:  循环监听的时间，每隔多少秒监听一次    """    for i in r:   当有任何可读就执行这里，这个就是事件循环。阻塞点 1        print(-----,r)        if i == server:            conn,addr = i.accept()            r_List.append(conn)   将链接通道 conn 放入监听队列        else:   如果不是server端，那就是conn，链接通道            :                data = i.recv(1024)   阻塞点2                not data:                 i.send(data.upper())             ConnectionresetError:                断开链接通道 将conn从可读列表中移除        1.开启服务端，监听可读事件列表 r_List,r_List = [socket对象,]  现在的r = []    2.开启客户端，发送请求链接，r 列表新增了一个可读  r = [socket对象] ，执行for循环，条件成立    3.建立双向链接通道，将链接通道放入可读事件列表 r_List = [socket对象，conn1]    # --- 客户端给服务端发消息 ---    1.此时的被监听列表 r_List = [socket对象，conn1]    2.客户端发了一个消息， r_List = [conn1,]    3. 执行for循环，条件不成立    # --- 客户端断开链接 ---    1.从监听列表 r_List 中删除了 conn1    """

selectors模块与异步

　　selectors 包可以自动根据 *** 作系统选择poll还是epoll，windows不支持epoll。

　　selectors包作为select包的升级版，更推荐去使用

　　select包目前只支持select方法。

　　现在很多框架的内部，如著名的异步框架tornado，Twisted ，等等都是通过epoll实现的异步，其实epoll到底属于不属于异步在网络上有很大的争议，下面会有一节解释一下我认为比较好的一个答案。

　　官方文档

　　如果是epoll，只有一个阻塞点，那就是recv()从内核态的缓冲区复制数据到用户态内存

 selectorssel = selectors.DefaultSelector()   自动选择，select，poll，epolldef accept(sock,mask):    conn,clIEnt_addr = sock.accept()   拿到双向链接    新的双向链接通道{0}来自{1}.format(conn,clIEnt_addr))    sel.register(conn,selectors.EVENT_READ,read)   为conn注册可读事件，绑定回调函数read read(conn,mask):    try:   <--针对 windows 平台客户端强制退出服务端会抛出异常        data = conn.recv(1024)        not data:   <-- 针对 UNIX 平台客户端强制退出服务端会无限收空            close_conn(conn,mask)        conn.send(data.upper())     ConnectionresetError as e:        close_conn(conn,mask) close_conn(conn,mask):    sel.unregister(conn)   注销对conn双向链接通道的监听     socket.socket()server.bind(())server.Listen(5)server.setblocking(False)   设置非阻塞sel.register(server,accept)   为server注册可读事件，回调函数为accept run():    while 1:   只要有注册的事件触发了，就会执行相应的回调函数，这里是死循环不断检测        events = sel.select(5)   最大监听时间        for key,mask in events:            callback = key.data   key.data 就是回调函数            callback(key.fileobj,mask)   执行回调，key.fileobj是监听的对象，也就是注册时的对象。if __name__ == '__main__':    run()

　　其实我们这里已经实现了单线程来模拟多线程的监听，但是如果返回结果的时候是同时很多clIEnt端都来了，那么我们可以使用多线程来进行 *** 作。

from concurrent.futures  ThreadPoolExecutor     events:            with ThreadPoolExecutor(5) as pool:                callback = key.data   key.data 就是回调函数                pool.submit(callback,key.fileobj,1)"> 执行回调，key.fileobj是监听的对象，也就是注册时的对象。

　　单线程中模拟多线程，是阻塞I/O以及单纯的非阻塞I/O都做不到的，他们都需要开多线程或者多进程，当然除了I/O多路复用，还有协程可以供我们使用。

扩展：epoll到底是属于同步还是异步

　　学习tornado、asyncio这些异步网络库时，遇到了同样的问题，网上查到的也都说不明白，原来几个概念没搞清楚。

　　　　1，I/O *** 作有多种，处理socket是一种，磁盘读写也是一种，暂时分为网络I/O和文件I/O、

　　　　2，I/O多路复用是 *** 作系统级别的，属于linux *** 作系统的五种I/O模型中的一种，是 *** 作系统级别同步非阻塞的。

　　　　3，异步网络库 twisted、tornado、asyncio所谓的异步，是应用级别的异步，底层确实是基于epoll实现，基本上都是处理网络 I/O，而且都是基于事件驱动的，使用时划分事件也大多是根据网络请求。

　　　　4， *** 作系统级别的异步I/O才是真正异步非阻塞的，然后并没有很多应用，貌似unix平台没有，windows NT平台有也很少，而且基本都是文件I/O。

　　　　5，I/O多路复用的实现用的比较多，linux平台的epoll，windows平台的select等，基于epoll，select的应用大多是实现网络I/O。

　　所以，遇到异步框架，异步网络库都应该知道是应用级别的异步，而且基本上都是基于epoll/select实现的。

　　已知tornado会根据系统平台，选择epoll还是select。

　　实现高并发有多种方式，python多进程可以利用多核优势，协程(gevent、asyncio)可以实现应用级别的异步，celery实现任务异步，消息队列实现服务解耦等等，项目中可以根据实际情况选择或组合不同的方式。

　　tornado(web框架/异步网络库)：进程+异步+epoll

　　asyncio：协程+epoll，使用中需要相应的异步库，常用aiohttp

　　gevent：greenlet+猴子补丁，猴子补丁把socket相关库改为非阻塞

　　摘自知乎：个人理解，应用层上的epoll确实是属于异步，而系统层上的epoll并非绝对意义上的异步。

扩展：协程

　　协程是不是一个真实存在的东西，但是线程和进程都是 *** 作系统中真实存在的，协程也是做到在单线程中实现并发的效果。

　　协程是程序员创造出的一个不是真实的东西

　　协程可以认为是微线程，对一个线程进程进行分片，

　　使得线程在代码块之间可以进行来回切换，而不是在原来的基础上逐行执行。

　　一个线程中函数的切换，使得它的切换代价非常低。

　　注意：单纯的协程是没有什么用的，就只是做做切换，你甚至可以用生成器函数yIEld来完成。

必须在只有一个单线程里实现并发

修改共享数据不需加锁

用户程序里自己保存多个控制流的上下文栈

附加：一个协程遇到I/O *** 作自动切换到其它协程（如何实现检测I/O，yIEld、greenlet都无法实现，就用到了gevent模块（select机制））

　　greenlet协程模块： 人为做切换

 greenlet f1():    print(1)    gr2.switch()  执行协程2    print(2)    gr2.switch() f2():    print(3)    gr1.switch()    print(4 表示创建了2个协程。由1个线程创建出来的gr1 = greenlet.greenlet(f1)  gr2 = greenlet.greenlet(f2)gr1.switch()   执行协程1 ==== 执行结果 ====1324"""

　　gevent模块 ： greenlet + IO切换，单纯的协程虽然没什么用，但是如果能够智能的碰见I/O就自己做切换，那就非常牛逼了。

 geventfrom gevent  monkeymonkey.patch_all()   对以下代码中有IO *** 作就切换 requests f(url):    res = requests.get(url)   碰见 I/O 自动切换自另一个协程    print(url,res.text)gevent.joinall([    gevent.spawn(f,https://www.baIDu.com/"), 协程 1    gevent.spawn(f,1)">https://www.yahoo.com/ 协程 2])

　　1.协程能提高并发吗 ?

　　答:协程本身是无法提高并发的,但是协程+I/O切换可以.

　　2.单线程提高并发的方法是？

　　协程+IO切换 gevent，基于事件循环的异步非阻塞框架 Twisted。

　　3.进程,线程,协程的区别是什么？

　　进程是资源分配的最小单位,线程是cpu调度的最小单位.

　　在一个程序中可以有多个进行,一个进程最少有一个线程.

　　和其他语言相比较,其他语言几乎不用进程的,但是在Python中,它的进程和线程是有差异的,Python有个GIL锁,GIL锁保证一个进程在同一时刻只有一个线程被cpu调到.

　　对于协程来说,它是有程序员创造出来的不是一个真实存在的东西,它本身是没有意义的,但是当 协程+I/O切换放到一起的时候就可以提高单线程并发的性能.

 

总结

以上是内存溢出为你收集整理的I/O模型实际应用与协程全部内容，希望文章能够帮你解决I/O模型实际应用与协程所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。