自定义IO异步基础知识：
--所有的请求都基于socket实现，一个请求就是一个socket
socket.setblocking(False) 不需要阻塞，一个请求完了发送另外一个，会报错，需解决
--IO多路复用[是同步的请求]
IO多路复用有epoll， poll, select，知道epoll性能比其他几者要好[epoll先找到门牌号然后找人]。
IO多路复用本质上是在同一个线程或进程中，通过拨动开关的方式来执行多个IO操作。注意实际上每个IO操作都是独立进行的。只是由原来的一对一变成了多对多。
r,w,e = select.select([],[],[], 超时时间) # socket有请求/响应前面的r,w,e都会接收到的
IO异步原理：
IO异步的实现：本质则是【非阻塞Socket】+【IO多路复用】
IO异步的实现：本质则是【非阻塞Socket】+【IO多路复用】
import select
import socket
import time
class AsyncTimeoutException(TimeoutError):
"""
请求超时异常类
"""
def __init__(self, msg):
self.msg = msg
super(AsyncTimeoutException, self).__init__(msg)
# 封装了socket和buffer的对象
class HttpContext(object):
"""封装请求和相应的基本数据"""
def __init__(self, sock, host, port, method, url, data, callback, timeout=5):
"""
sock: 请求的客户端socket对象
host: 请求的主机名
port: 请求的端口
port: 请求的端口
method: 请求方式
url: 请求的URL
data: 请求时请求体中的数据
callback: 请求完成后的回调函数
timeout: 请求的超时时间
"""
self.sock = sock
self.callback = callback
self.host = host
self.port = port
self.method = method
self.url = url
self.data = data
self.timeout = timeout
self.__start_time = time.time()
self.__buffer = []
def is_timeout(self):
"""当前请求是否已经超时"""
current_time = time.time()
if (self.__start_time + self.timeout) < current_time:
return True
def fileno(self):
"""请求sockect对象的文件描述符，用于select监听"""
return self.sock.fileno()
def write(self, data):
"""在buffer中写入响应内容"""
self.__buffer.append(data)
def finish(self, exc=None):
"""在buffer中写入响应内容完成，执行请求的回调函数"""
if not exc:
response = b''.join(self.__buffer)
self.callback(self, response, exc)
else:
self.callback(self, None, exc)
def send_request_data(self):
content = """%s %s HTTP/1.0
Host: %s
%s""" % (
self.method.upper(), self.url, self.host, self.data,)
return content.encode(encoding='utf8')
class AsyncRequest(object):
def __init__(self):
self.fds = []
self.connections = []
def add_request(self, host, port, method, url, data, callback, timeout):
"""创建一个要请求"""
client = socket.socket()
client.setblocking(False) # 不阻塞请求，不等待回应
try:
client.connect((host, port))
except BlockingIOError as e:
pass
# print('已经向远程发送连接的请求')
req = HttpContext(client, host, port, method, url, data, callback, timeout)
self.connections.append(req) # 封装HttpContext对象
self.fds.append(req)
def check_conn_timeout(self):
"""检查所有的请求，是否有已经连接超时，如果有则终止"""
timeout_list = []
for context in self.connections:
if context.is_timeout():
timeout_list.append(context)
for context in timeout_list:
context.finish(AsyncTimeoutException('请求超时'))
self.fds.remove(context)
self.connections.remove(context)
def running(self):
"""事件循环，用于检测请求的socket是否已经就绪，从而执行相关操作"""
while True:
r, w, e = select.select(self.fds, self.connections, self.fds, 0.05)
if not self.fds:
return
for context in r:
sock = context.sock
while True:
try:
data = sock.recv(8096)
if not data:
self.fds.remove(context)
context.finish()
break
else:
context.write(data)
except BlockingIOError as e:
break
except TimeoutError as e:
self.fds.remove(context)
self.connections.remove(context)
context.finish(e)
break
for context in w:
# 已经连接成功远程服务器，开始向远程发送请求数据
if context in self.fds:
data = context.send_request_data()
context.sock.sendall(data)
self.connections.remove(context)
self.check_conn_timeout()
if __name__ == '__main__':
def callback_func(context, response, ex):
"""
:param context: HttpContext对象，内部封装了请求相关信息
:param response: 请求响应内容
:param ex: 是否出现异常（如果有异常则值为异常对象；否则值为None）
:return:
"""
print(context, response, ex)
obj = AsyncRequest()
# 基于TCP构造HTTP
url_list = [
{'host': 'www.google.com', 'port': 80, 'method': 'GET', 'url': '/', 'data': '', 'timeout': 5,
'callback': callback_func},
{'host': 'www.baidu.com', 'port': 80, 'method': 'GET', 'url': '/', 'data': '', 'timeout': 5, 'callback': callback_func},
{'host': 'www.bing.com', 'port': 80, 'method': 'GET', 'url': '/', 'data': '', 'timeout': 5, 'callback': callback_func},
]
for item in url_list:
print(item)
obj.add_request(**item)
obj.running()
