承接上一节课，我们在上节课中提到，socket I/O 阻塞时的那段时间完全被浪费了，那么要如何节省下那一段时间呢？
非阻塞I/O
如果使用非阻塞I/O，它就不会傻傻地等在那里(比如等连接、等读取)，而是会返回一个错误信息，虽然说是说错误信息，它其实就是叫你过一会再来的意思，编程的时候都不把它当错误看。
非阻塞I/O代码如下：
sock = socket.socket()
sock.setblocking(False)
try:
sock.connect((‘xkcd.com‘, 80))
except BlockingIOError:
pass
这里抛出的异常无视掉就可以了。
单线程上的多I/O
有了非阻塞I/O这个特性，我们就能够实现单线程上多个sockets的处理了，学过C语言网络编程的同学应该都认识select这个函数吧？不认识也不要紧，select函数如果你不设置它的超时时间它就是默认一直阻塞的，只有当有I/O事件发生时它才会被激活，然后告诉你哪个socket上发生了什么事件（读|写|异常），在Python中也有select，还有跟select功能相同但是更高效的poll，它们都是底层C函数的Python实现。
不过这里我们不使用select，而是用更简单好用的DefaultSelector，是Python 3.4后才出现的一个模块里的类，你只需要在非阻塞socket和事件上绑定回调函数就可以了。
代码如下：
from selectors import DefaultSelector, EVENT_WRITE
selector = DefaultSelector()
sock = socket.socket()
sock.setblocking(False)
try:
sock.connect((‘localhost‘, 3000))
except BlockingIOError:
pass
def connected():
selector.unregister(sock.fileno())
print(‘connected!‘)
selector.register(sock.fileno(), EVENT_WRITE, connected)
这里看一下selector.register的原型
register(fileobj, events, data=None)
其中fileobj可以是文件描述符也可以是文件对象（通过fileno得到），events是位掩码，指明发生的是什么事件，data 则是与指定文件（也就是我们的socket）与指定事件绑定在一起的数据。
如代码所示，selector.register 在该socket的写事件上绑定了回调函数connected（这里作为数据绑定）。在该socket上第一次发生的写事件意味着连接的建立，connected函数在连接建立成功后再解除了该socket上所有绑定的数据。
事件驱动
看了以上selector的使用方式，我想你会发现它很适合写成事件驱动的形式。
我们可以创建一个事件循环，在循环中不断获得I/O事件：
def loop():
while True:
events = selector.select()
#遍历事件并调用相应的处理
for event_key, event_mask in events:
callback = event_key.data
callback()
其中events_key是一个namedtuple，它的结构大致如下(fileobj,fd,events,data)，我们从data得到之前绑定的回调函数并调用。 event_mask则是事件的位掩码。
关于selectors的更多内容，可参考官方文档： https://docs.python.org/3.4/library/selectors.html
完成后续工作
现在我们已经明白了基于回调函数实现事件驱动是怎么一回事了，接着来完成我们的爬虫吧。
首先创建两个set，一个是待处理url的集合，一个是已抓取url的集合，同时初始化为根url ‘/‘
urls_todo = set([‘/‘])
seen_urls = set([‘/‘])
抓取一个页面会需要许多回调函数。比如connected，它会在连接建立成功后向服务器发送一个GET请求请求页面。当然它不会干等着服务器响应（那就阻塞了），而是再绑定另一个接收响应的回调函数read_response。如果read_response在事件触发时无法一次性读取完整的响应，那么就会等下次事件触发时继续读取，直到读取到了完整的响应才解除绑定。
我们将这些回调函数封装在 Fetcher 类中。它有三个成员变量：抓取的url、socket对象与得到的服务器响应response。
class Fetcher:
def __init__(self, url):
self.response = b‘‘
self.url = url
self.sock = None
实现fetch函数，绑定connected：
# 在Fetcher类中实现
def fetch(self):
self.sock = socket.socket()
self.sock.setblocking(False)
try:
self.sock.connect((‘xkcd.com‘, 80))
except BlockingIOError:
pass
selector.register(self.sock.fileno(),
EVENT_WRITE,
self.connected)
注意到fetch函数在内部调用connect尝试建立socket连接并绑定回调函数，I/O的处理则都是交给事件循环控制的。Fetcher与事件循环的关系如下：
# Begin fetching http://xkcd.com/353/
fetcher = Fetcher(‘/353/‘)
fetcher.fetch()
# 事件循环
while True:
events = selector.select()
for event_key, event_mask in events:
callback = event_key.data
callback(event_key, event_mask)
connected的实现：
def connected(self, key, mask):
print(‘connected!‘)
#解除该socket上的所有绑定
selector.unregister(key.fd)
request = ‘GET {} HTTP/1.0\r\nHost: xkcd.com\r\n\r\n‘.format(self.url)
self.sock.send(request.encode(‘ascii‘))
# 连接建立后绑定读取响应的回调函数
selector.register(key.fd,
EVENT_READ,
self.read_response)
read_response的实现：
def read_response(self, key, mask):
global stopped
chunk = self.sock.recv(4096) # 每次接收最多4K的信息
if chunk:
self.response += chunk
else:
selector.unregister(key.fd) # 完成接收则解除绑定
links = self.parse_links()
# Python set-logic:
for link in links.difference(seen_urls):
urls_todo.add(link)
Fetcher(link).fetch() # 抓取新的url
seen_urls.update(links)
urls_todo.remove(self.url)
if not urls_todo:
stopped = True # 当抓取队列为空时结束事件循环
parse_links 如上一节课，它的作用是返回抓取到的页面中的所有发现的url的集合。 parse_links 之后，遍历了每一个没抓取过的url并为其创建一个新的Fetcher 对象并调用fetch 函数开始抓取。
parse_links等其它函数的实现：
def body(self):
body = self.response.split(b‘\r\n\r\n‘, 1)[1]
return body.decode(‘utf-8‘)
def parse_links(self):
if not self.response:
print(‘error: {}‘.format(self.url))
return set()
if not self._is_html():
return set()
urls = set(re.findall(r‘‘‘(?i)href=["‘]?([^\s"‘<>]+)‘‘‘,
self.body()))
links = set()
for url in urls:
normalized = urllib.parse.urljoin(self.url, url)
parts = urllib.parse.urlparse(normalized)
if parts.scheme not in (‘‘, ‘http‘, ‘https‘):
continue
host, port = urllib.parse.splitport(parts.netloc)
if host and host.lower() not in (‘xkcd.com‘, ‘www.xkcd.com‘):
continue
defragmented, frag = urllib.parse.urldefrag(parts.path)
links.add(defragmented)
return links
def _is_html(self):
head, body = self.response.split(b‘\r\n\r\n‘, 1)
headers = dict(h.split(‘: ‘) for h in head.decode().split(‘\r\n‘)[1:])
return headers.get(‘Content-Type‘, ‘‘).startswith(‘text/html‘)
将事件循环改为stopped时停止：
start = time.time()
stopped = False
def loop():
while not stopped:
events = selector.select()
for event_key, event_mask in events:
callback = event_key.data
callback()
print(‘{} URLs fetched in {:.1f} seconds‘.format(
len(seen_urls), time.time() - start))
运行效果
这里先奉上完整代码：
from selectors import *
import socket
import re
import urllib.parse
import time
urls_todo = set([‘/‘])
seen_urls = set([‘/‘])
#追加了一个可以看最高并发数的变量
concurrency_achieved = 0
selector = DefaultSelector()
stopped = False
class Fetcher:
def __init__(self, url):
self.response = b‘‘
self.url = url
self.sock = None
def fetch(self):
global concurrency_achieved
concurrency_achieved = max(concurrency_achieved, len(urls_todo))
self.sock = socket.socket()
self.sock.setblocking(False)
try:
self.sock.connect((‘localhost‘, 3000))
except BlockingIOError:
pass
selector.register(self.sock.fileno(), EVENT_WRITE, self.connected)
def connected(self, key, mask):
selector.unregister(key.fd)
get = ‘GET {} HTTP/1.0\r\nHost: localhost\r\n\r\n‘.format(self.url)
self.sock.send(get.encode(‘ascii‘))
selector.register(key.fd, EVENT_READ, self.read_response)
def read_response(self, key, mask):
global stopped
chunk = self.sock.recv(4096) # 4k chunk size.
if chunk:
self.response += chunk
else:
selector.unregister(key.fd) # Done reading.
links = self.parse_links()
for link in links.difference(seen_urls):
urls_todo.add(link)
Fetcher(link).fetch()
seen_urls.update(links)
urls_todo.remove(self.url)
if not urls_todo:
stopped = True
print(self.url)
def body(self):
body = self.response.split(b‘\r\n\r\n‘, 1)[1]
return body.decode(‘utf-8‘)
def parse_links(self):
if not self.response:
print(‘error: {}‘.format(self.url))
return set()
if not self._is_html():
return set()
urls = set(re.findall(r‘‘‘(?i)href=["‘]?([^\s"‘<>]+)‘‘‘,
self.body()))
links = set()
for url in urls:
normalized = urllib.parse.urljoin(self.url, url)
parts = urllib.parse.urlparse(normalized)
if parts.scheme not in (‘‘, ‘http‘, ‘https‘):
continue
host, port = urllib.parse.splitport(parts.netloc)
if host and host.lower() not in (‘localhost‘):
continue
defragmented, frag = urllib.parse.urldefrag(parts.path)
links.add(defragmented)
return links
def _is_html(self):
head, body = self.response.split(b‘\r\n\r\n‘, 1)
headers = dict(h.split(‘: ‘) for h in head.decode().split(‘\r\n‘)[1:])
return headers.get(‘Content-Type‘, ‘‘).startswith(‘text/html‘)
start = time.time()
fetcher = Fetcher(‘/‘)
fetcher.fetch()
while not stopped:
events = selector.select()
for event_key, event_mask in events:
callback = event_key.data
callback(event_key, event_mask)
print(‘{} URLs fetched in {:.1f} seconds, achieved concurrency = {}‘.format(
len(seen_urls), time.time() - start, concurrency_achieved))
输入python3 callback.py命令查看效果。不要忘了先开网站的服务器哦。
基于回调函数实现的缺陷
想想之前从建立连接到读取响应到解析新的url到工作队列中，这一切都能够在一个函数中完成，就像下面这样：
def fetch(url):
sock = socket.socket()
sock.connect((‘localhost‘, 3000))
request = ‘GET {} HTTP/1.0\r\nHost: localhost\r\n\r\n‘.format(url)
sock.send(request.encode(‘ascii‘))
response = b‘‘
chunk = sock.recv(4096)
while chunk:
response += chunk
chunk = sock.recv(4096)
links = parse_links(response)
q.add(links)
而用回调函数实现，整个整体就支离破碎了，哪里阻塞就又不得不在那里把函数一切为二，代码会显得非常乱，维护也变的很麻烦。更麻烦的是如果在回调函数中抛出了异常，你根本得不到什么有用的信息：
Traceback (most recent call last):
File "loop-with-callbacks.py", line 111, in <module>
loop()
File "loop-with-callbacks.py", line 106, in loop
callback(event_key, event_mask)
File "loop-with-callbacks.py", line 51, in read_response
links = self.parse_links()
File "loop-with-callbacks.py", line 67, in parse_links
raise Exception(‘parse error‘)
Exception: parse error
你看不到这个回调函数的上下文是什么，你只知道它在事件循环里。你想在这个函数外抓取它的异常都没地方下手。但是这又是回调实现无法避免的缺陷，那我们想实现并发异步应该怎么办咧？