denglj / aiotutorial Goto Github PK

class Future:
    def __init__(self):
        self.result = None
        self._callback = None

    def add_done_callback(self, fn):
        self._callback = fn

    def set_result(self, result):
        self.result = result
        if self._callback:
            self._callback(self)

#! -*- coding: utf-8 -*-


# author: [email protected]


import time
import select
import socket
import operator


# 静态类,零时存储可读可写连接
class Cache(object):
    can_read = {}
    can_write = {}


class Client(object):
    def __init__(self):
        self._socket = None

    def connect(self, host, port, uri, **kwargs):
        self._socket = socket.socket(**kwargs)
        # 设置此sock上的调用全部改为非阻塞
        self._socket.setblocking(False)
        try:
            # 非阻塞模式会抛异常
            self._socket.connect((host, port))
        except socket.error:
            pass
        # 创建完连接放入可写字典
        Cache.can_write[self._socket] = self

    def req_handle(self):
        _req = 'GET {0} HTTP/1.0\r\nHOST:{1}\r\n\r\n'.format(uri, host)
        self._socket.send(_req)
        # 发送完数据放入可读字典
        Cache.can_read[self._socket] = self

    def rsp_handle(self, buffersize=4096):
        _rsp = ''
        # select在非阻塞模式下可能出现误判导致数据未准备就绪,这里做一下简单处理
        while True:
            try:
                chunk = self._socket.recv(buffersize)
                while chunk:
                    _rsp += chunk
                    chunk = self._socket.recv(buffersize)
                break
            except socket.error:
                continue
        return _rsp


if __name__ == '__main__':
    results = []
    # 存存储耗时
    runcost = [time.time()]
    host, port, uri = '10.246.26.13', 80, '/ne_screen/jbscreen/lebo/screen/connect-totaltime/?from=2018-01-01&to=2018-12-3'
    for _ in xrange(20):
        c = Client()
        # 异步创建20个连接放入可写字典
        c.connect(host, port, uri)
    while True:
        # 处理完20个请求就退出
        if not Cache.can_read and not Cache.can_write:
            break
        # 监听读写事件
        rlist, wlist, _ = select.select(Cache.can_read, Cache.can_write, [])
        if rlist:
            # 可读就读取
            for sock in rlist:
                client = Cache.can_read.pop(sock)
                results.append(client.rsp_handle())
        if wlist:
            # 可写就请求
            for sock in wlist:
                client = Cache.can_write.pop(sock)
                client.req_handle()

    runcost.insert(0, time.time())
    print 'Request Times: {0}, Total Cost: {1} seconds'.format(
        len(results),
        operator.sub(*runcost)
    )

"""
Request Times: 20, Total Cost: 1.52134513855 seconds
"""