协程和异步IO-中

我们接着上小节的学习，现在我们进行一下测试，分别是非阻塞I/O，和使用select实现的IO复用。

使用非阻塞io完成http请求

import socket
from urllib.parse import urlparse

def get_url(url):
    # 通过socket请求html
    url = urlparse(url)
    host = url.netloc
    path = url.path
    if path == "":
        path = "/"

    # 建立socket连接
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # 我们通过设置 setblocking 为 False 来设置为非阻塞
    client.setblocking(False)
    
    # 在使用到 client 的地方我们都要进行异常捕捉
    try:
        client.connect((host, 80))  # 阻塞不会消耗cpu
    except BlockingIOError as e:
        pass

    # 不停的询问连接是否建立好， 需要while循环不停的去检查状态
    
    # 做计算任务或者再次发起其他的连接请求

    while True:
        # 在使用到 client 的地方我们都要进行异常捕捉
        try:
            client.send("GET {} HTTP/1.1\r\nHost:{}\r\nConnection:close\r\n\r\n".format(path, host).encode("utf8"))
            break
        except OSError as e:
            pass

          
    data = b""
    while True:
        # 在使用到 client 的地方我们都要进行异常捕捉
        try:
            d = client.recv(1024)
        except BlockingIOError as e:
            continue
        if d:
            data += d
        else:
            break

    data = data.decode("utf8")
    html_data = data.split("\r\n\r\n")[1]
    print(html_data)
    client.close()


if __name__ == "__main__":
    get_url("http://www.baidu.com")

从上面代码中，我们看到当下面代码依赖于某个非阻塞I/O操作的时候，整体效率提示是不大的。

回调 + 事件循环+select（poll，epoll）

我们看下通过select实现的I/O复用。

单线程中。。

# 并发性高
# 使用单线程

import socket
from urllib.parse import urlparse
from selectors import DefaultSelector, EVENT_READ, EVENT_WRITE

# 这里我们使用的是 重构后的 selectors  底层还是使用 select模块实现的
# selectors 实现了一种注册机制

# 实例化一个 select对象
selector = DefaultSelector()

# 使用select完成http请求
urls = []
stop = False


class Fetcher:
    # 我们在注册 select 的时候 有设置回调函数 select 会将文件描述符当做第一个参数传入到 回调函数中 
    # 当建立连接时候的回调
    def connected(self, key):
        # 这个 key 就是文件描述符
        
        # 在回调函数中 我们要注销掉监控的事件
        selector.unregister(key.fd)
        
        # 进到这里就是已经建立连接的 不再需要异常捕捉
        self.client.send(
            "GET {} HTTP/1.1\r\nHost:{}\r\nConnection:close\r\n\r\n".format(self.path, self.host).encode("utf8"))
        
        # 现在我们需要接受数据 即读数据
        # 再次注册 可写事件到 select 设置回调函数
        # 三个参数 依次是文件描述符 事件 回调函数
        selector.register(self.client.fileno(), EVENT_READ, self.readable)
	
    # 当可读时候测回调
    def readable(self, key):
        d = self.client.recv(1024)
        if d:
            self.data += d
        else:
            # 注销事件
            selector.unregister(key.fd)
            data = self.data.decode("utf8")
            html_data = data.split("\r\n\r\n")[1]
            print(html_data)
            self.client.close()
            urls.remove(self.spider_url)
            if not urls:
                global stop
                stop = True

    def get_url(self, url):
        self.spider_url = url
        url = urlparse(url)
        self.host = url.netloc
        self.path = url.path
        self.data = b""
        if self.path == "":
            self.path = "/"

        # 建立socket连接
        self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.client.setblocking(False)

        try:
            self.client.connect((self.host, 80))  # 阻塞不会消耗cpu
        except BlockingIOError as e:
            pass

        # 注册到 selectors
        # 我们将 client 的可写事件注册到select中 并设置回调函数
        selector.register(self.client.fileno(), EVENT_WRITE, self.connected)

# 即使我们已经写好了 回调 也不是系统直接在可读可写的时候进行直接调用回调函数
# 而是需要事件循环来实现 
        
        
# 虽然我们已经写了 注册事件到 select 但是还是要使用 事件循环进行调用回调函数

# 驱动程序运行的心脏
def loop():
    # 事件循环，不停的请求socket的状态并调用对应的回调函数
    
    # 1. select本身是不支持register模式
    # 2. socket状态变化以后的回调是由程序员完成的
    while not stop:
        ready = selector.select()	# 这个 ready 就是可以操作的 socket 队列
        for key, mask in ready:
            call_back = key.data	# key  就是准备就绪的描述符 key.data 就是回调函数
            call_back(key)	# 执行回调函数
            
    # 回调+事件循环+select(poll\epoll)

    
# 异步编程的核心都是这个事件循环 Tornado的底层也是实现了事件循环
# 这个事件循环是单线程的 通过循环中的函数进行注册和注销

if __name__ == "__main__":
    fetcher = Fetcher()
    import time
 
    start_time = time.time()
    for url in range(20):
        url = "http://shop.projectsedu.com/goods/{}/".format(url)
        urls.append(url)
        fetcher = Fetcher()
        fetcher.get_url(url)
    loop()
    print(time.time() - start_time)

三个函数的执行是：get_url —> connected —> readable

事件循环在IO多路复用中都存在的

回调的缺点：

1. 可读性差
2. 共享状态管理困难
3. 异常处理困难，回调发生的异常不能上抛到我们真正调的函数

下面我们学习的协程就是解决这种代码编写复杂，维护困难的而生的。💪