前言
用阻塞 api 写同步代码最简单，但一个线程同一时间只能处理一个请求，有限的线程数导致无法实现万级别的并发连接，过多的线程切换也抢走了 cpu 的时间，从而降低了每秒能够处理的请求数量。为了达到高并发，你可能会选择一个异步框架，用非阻塞 api 把业务逻辑打乱到多个回调函数，通过多路复用与事件循环的方式实现高并发。
磁盘 io 为例，描述了多线程中使用阻塞方法读磁盘，2 个线程间的切换方式。那么，怎么才能实现高并发呢？
把上图中本来由内核实现的请求切换工作，交由用户态的代码来完成就可以了，异步化编程通过应用层代码实现了请求切换，降低了切换成本和内存占用空间。异步化依赖于 io 多路复用机制，比如 linux 的 epoll 或者 windows 上的 iocp，同时，必须把阻塞方法更改为非阻塞方法，才能避免内核切换带来的巨大消耗。nginx、redis 等高性能服务都依赖异步化实现了百万量级的并发。
下图描述了异步 io 的非阻塞读和异步框架结合后，是如何切换请求的。
然而，写异步化代码很容易出错。因为所有阻塞函数，都需要通过非阻塞的系统调用拆分成两个函数。虽然这两个函数共同完成一个功能，但调用方式却不同。第一个函数由你显式调用，第二个函数则由多路复用机制调用。
这种方式违反了软件工程的内聚性原则，函数间同步数据也更复杂。特别是条件分支众多、涉及大量系统调用时，异步化的改造工作会非常困难。
python如何实现异步调用
from flask import flask
import time
app = flask(__name__)
@app.route('/bar')
def bar():
time.sleep(1)
return '<h1>bar!</h1>'
@app.route('/foo')
def foo():
time.sleep(1)
return '<h1>foo!</h1>'
if __name__ == '__main__':
app.run(host='127.0.0.1',port=5555,debug=true)
采用同步的方式调用
import requests
import time
starttime = time.time()
print(requests.get('http://127.0.0.1:5555/bar').content)
print(requests.get('http://127.0.0.1:5555/foo').content)
print("消耗时间: ",time.time() -starttime)
b'<h1>bar!</h1>'
b'<h1>foo!</h1>'
消耗时间: 2.015509605407715
采样异步的方式调用：
重点：
1.将阻塞io改为非阻塞io；
2.多路复用io监听内核事件，事件触发通过回调函数；
3.用户态代码采取事件循环的方式获取事件，执行事件的回调函数；
import selectors
import socket
import time
# from asynrequest import parserhttp
class asynhttp:
def __init__(self):
self.selecter = selectors.defaultselector()
def get(self,url,optiondict = none):
global reqcount
reqcount += 1
s = socket.socket()
s.setblocking(false)
try:
s.connect(('127.0.0.1',5555))
except blockingioerror:
pass
requset = 'get %s http/1.0\r\n\r\n' % url
callback = lambda : self.send(s,requset)
self.selecter.register(s.fileno(),selectors.event_write,callback)
def send(self,s,requset):
self.selecter.unregister(s.fileno())
s.send(requset.encode())
chunks = []
callback = lambda: self.recv(s,chunks)
self.selecter.register(s.fileno(),selectors.event_read,callback)
def recv(self,s,chunks):
self.selecter.unregister(s.fileno())
chunk = s.recv(1024)
if chunk:
chunks.append(chunk)
callback = lambda: self.recv(s,chunks)
self.selecter.register(s.fileno(), selectors.event_read, callback)
else:
global reqcount
reqcount -= 1
request_first,request_headers,request_content,_ = parserhttp.parser(b''.join(chunks))
print("解析数据：",request_first,request_headers,request_content)
print((b''.join(chunks)).decode())
return (b''.join(chunks)).decode()
starttime = time.time()
reqcount = 0
asynhttper = asynhttp()
asynhttper.get('/bar')
asynhttper.get('/foo')
while reqcount:
events = asynhttper.selecter.select()
for event,mask in events:
func = event.data
func()
print("消耗时间：" ,time.time() - starttime)
http/1.0 200 ok
content-type: text/html; charset=utf-8
content-length: 13
server: werkzeug/1.0.1 python/3.7.7
date: thu, 15 oct 2020 03:28:16 gmt<h1>bar!</h1>
http/1.0 200 ok
content-type: text/html; charset=utf-8
content-length: 13
server: werkzeug/1.0.1 python/3.7.7
date: thu, 15 oct 2020 03:28:16 gmt<h1>foo!</h1>
消耗时间： 1.0127637386322021
以上就是python实现异步io的示例的详细内容，更多关于python 异步io的资料请关注其它相关文章！
