Python學習---IO的異步[自定義異步IO]

自定義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\r\nHost: %s\r\n\r\n%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()