ime : 2.0327329635620117
感觉被骗了，速度还是跟第一个一样啊，看来非阻塞IO并没有什么速度上的提升啊，问题出在哪里呢？看代码发现多了两个while循环：
1 while True:
2 try:
3 sock.send("GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: Close\r\n\r\n".encode("utf-8"))
4 # 直到send 不抛出异常，就发送成功了
5 break
6 except OSError:
7 pass
8 while True:
9 try:
10 response = sock.recv(1024)
11 break
12 except OSError:
13 pass
因为把socket设置为非阻塞模式了，所以CPU并不知道IO什么时候就绪，所以必须在这里不停的尝试，直到IO可以使用了为止。
虽然 connect() 和 recv() 不再阻塞主程序，空出来的时间段CPU没有空闲着，但并没有利用好这空闲去做其他有意义的事情，而是在循环尝试读写 socket （不停判断非阻塞调用的状态是否就绪）。
有没有办法让CPU空闲出来的时间，不用来不停的询问IO，而是干别的更有意义的事情呢，等IO就绪后再通知CPU回来处理呢？当然有了，那就是回调。
4. 改进3-回调
操作系统已经把IO状态的改变封装成了事件，如可读事件、可写事件。并且可以为这些事件绑定处理函数。所以我们可以使用这种方式，为socket的IO状态的变化绑定处理函数，交给系统进行调动，这样就是回调方式。python的select模块支持这样的操作。
代码如下：
1 import socket
2 from selectors import DefaultSelector, EVENT_WRITE, EVENT_READ
3 import sys
4 selector = DefaultSelector()
5 stopped = False
6 urls_todo = []
7
8 class Crawler:
9 def __init__(self, url):
10 self.url = url
11 self.sock = None
12 self.response = b''
13
14 def fetch(self):
15 self.sock = socket.socket()
16 self.sock.setblocking(False)
17 try:
18 self.sock.connect(('www.baidu.com', 80))
19 except BlockingIOError:
20 pass
21 selector.register(self.sock.fileno(), EVENT_WRITE, self.connected)
22
23 def connected(self, key, mask):
24 selector.unregister(key.fd)
25 get = 'GET {0} HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.format(self.url)
26 self.sock.send(get.encode('ascii'))
27 selector.register(key.fd, EVENT_READ, self.read_response)
28
29 def read_response(self, key, mask):
30 global stopped
31 # 如果响应大于4KB，下一次循环会继续读
32 chunk = self.sock.recv(4096)
33 if chunk:
34 self.response += chunk
35 else:
36 selector.unregister(key.fd)
37 urls_todo.remove(self.url)
38 if not urls_todo:
39 stopped = True
40
41 def loop():
42 while not stopped:
43 # 阻塞, 直到一个事件发生
44 events = selector.select()
45 for event_key, event_mask in events:
46 callback = event_key.data
47 callback(event_key, event_mask)
48
49 if __name__ == '__main__':
50 import time
51 start = time.time()
52 for i in range(int(sys.argv[1])):
53 urls_todo.append("/"+str(i))
54 crawler = Crawler("/"+str(i))
55 crawler.fetch()
56 loop()
57 print("spend time : %s" %(time.time()-start))
监控socket的状态，如果变为可写的，就往里面写数据
selector.register(self.sock.fileno(), EVENT_WRITE, self.connected)
监控socket的状态，如果变为可读的，就外读数据
selector.register(key.fd, EVENT_READ, self.read_response)
测试一下速度：
1 ? python3 4.py 10
2 spend time : 0.03910994529724121
3 ? python3 4.py 20
4 spend time : 0.04195284843444824
我们看到速度已经有个一个质的飞跃了，但是回调用一些严重的问题，会破坏代码的本来的逻辑结构，造成代码可读性很差。
比如我们有函数 funcA,funcB,funcC三个函数，如果funcC处理的结果依赖于funcB的处理结果，funcB的处理结果依赖于funcA的处理结果，而funcA又是回调的方式调用的，所以就不知道funcA什么时候返回，所以只能将后续的处理都作为callback的方式传入funcA中，让funcA执行完了可以执行funcB，funcB执行完了可以执行funcC，看起来像下面这样：
funcA(funcB(funcC()))
这就形成了一个链式的回调，跟最初的代码逻辑完全相反，本来的逻辑应该是这样的。
funcC(funcB(funcA()))
因为这样的链式回调的出现，导致了理解代码逻辑困难，并且错误处理困难。
有没有方法避免这种地狱式的链式回调的呢？
5 .改进4-利用生成器
可以利用python的生成器，把发请求的函数写成一个生成器，然后只监控IO的状态，当IO状态发生改变之后，就给生成器传送值，驱动生成器进行下一步操作，这样就可以避免回调了，具体实现如下：
1 import select
2 import socket
3 import time
4 import sys
5
6 num = int(sys.argv[1])
7
8 def coroutine():
9 sock = socket.socket()
10 sock.setblocking(0)
11