asynicio模块以及爬虫应用asynicio模块(高性能爬虫)

一、背景知识

爬虫的本质就是一个socket客户端与服务端的通信过程，如果我们有多个url待爬取，只用一个线程且采用串行的方式执行，那只能等待爬取一个结束后才能继续下一个，效率会非常低。

需要强调的是：对于单线程下串行N个任务，并不完全等同于低效，如果这N个任务都是纯计算的任务，那么该线程对cpu的利用率仍然会很高，之所以单线程下串行多个爬虫任务低效，是因为爬虫任务是明显的IO密集型程序。

二、同步、异步、回调机制

1、同步调用：即提交一个任务后就在原地等待任务结束，等到拿到任务的结果后再继续下一行代码，效率低下

import requests

def parse_page(res):
    print('解析 %s' %(len(res)))

def get_page(url):
    print('下载 %s' %url)
    response=requests.get(url)
    if response.status_code == 200:
        return response.text

urls=['https://www.baidu.com/','http://www.sina.com.cn/','https://www.python.org']
for url in urls:
    res=get_page(url) #调用一个任务，就在原地等待任务结束拿到结果后才继续往后执行
    parse_page(res)

2、一个简单的解决方案：多线程或多进程

#在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每个连接都拥有独立的线程（或进程），
这样任何一个连接的阻塞都不会影响其他的连接。

#IO密集型程序应该用多线程
import requests
from threading import Thread,current_thread

def parse_page(res):
    print('%s 解析 %s' %(current_thread().getName(),len(res)))

def get_page(url,callback=parse_page):
    print('%s 下载 %s' %(current_thread().getName(),url))
    response=requests.get(url)
    if response.status_code == 200:
        callback(response.text)

if __name__ == '__main__':
    urls=['https://www.baidu.com/','http://www.sina.com.cn/','https://www.python.org']
    for url in urls:
        t=Thread(target=get_page,args=(url,))
        t.start()

   该方案的问题是：

开启多进程或都线程的方式，我们是无法无限制地开启多进程或多线程的：在遇到要同时响应成百上千路的连接请求，
则无论多线程还是多进程都会严重占据系统资源，降低系统对外界响应效率，而且线程与进程本身也更容易进入假死状态。
3、改进方案： 线程池或进程池+异步调用：提交一个任务后并不会等待任务结束，而是继续下一行代码

#很多程序员可能会考虑使用“线程池”或“连接池”。“线程池”旨在减少创建和销毁线程的频率，其维持一定合理数量的线程，
并让空闲的线程重新承担新的执行任务。“连接池”维持连接的缓存池，尽量重用已有的连接、减少创建和关闭连接的频率。
这两种技术都可以很好的降低系统开销，都被广泛应用很多大型系统，如websphere、tomcat和各种数据库等。

 #IO密集型程序应该用多线程，所以此时我们使用线程池
 import requests
 from threading import current_thread
 from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

 def parse_page(res):
     res=res.result()
     print('%s 解析 %s' %(current_thread().getName(),len(res)))

 def get_page(url):
     print('%s 下载 %s' %(current_thread().getName(),url))
     response=requests.get(url)
     if response.status_code == 200:
         return response.text

 if __name__ == '__main__':
     urls=['https://www.baidu.com/','http://www.sina.com.cn/','https://www.python.org']

     pool=ThreadPoolExecutor(50)
     # pool=ProcessPoolExecutor(50)
     for url in urls:
         pool.submit(get_page,url).add_done_callback(parse_page)

     pool.shutdown(wait=True)

进程池或线程池：异步调用+回调机制

    改进后方案其实也存在着问题：

#“线程池”和“连接池”技术也只是在一定程度上缓解了频繁调用IO接口带来的资源占用。而且，所谓“池”始终有其上限，
当请求大大超过上限时，“池”构成的系统对外界的响应并不比没有池的时候效果好多少。所以使用“池”必须考虑其面临的响应规模，
并根据响应规模调整“池”的大小

对应上例中的所面临的可能同时出现的上千甚至上万次的客户端请求，“线程池”或“连接池”或许可以缓解部分压力，但是不能解决所有问题。

总之，多线程模型可以方便高效的解决小规模的服务请求，但面对大规模的服务请求，多线程模型也会遇到瓶颈，可以用非阻塞接口来尝试解决这个问题。

三、高性能

上述无论哪种解决方案其实没有解决一个性能相关的问题：IO阻塞，无论是多进程还是多线程，在遇到IO阻塞时都会被操作系统强行剥夺走CPU的执行权限，程序的执行效率因此就降低了下来。

解决这一问题的关键在于，我们自己从应用程序级别检测IO阻塞然后切换到我们自己程序的其他任务执行，这样把我们程序的IO降到最低，我们的程序处于就绪态就会增多，以此来迷惑操作系统，操作系统便以为我们的程序是IO比较少的程序，从而会尽可能多的分配CPU给我们，这样也就达到了提升程序执行效率的目的

1、在python3.3之后新增了asyncio模块，可以帮我们检测IO（只能是网络IO），实现应用程序级别的切换

import asyncio
#当程序遇到IO的时候不阻塞了，让这个装饰器去检测有没有IO，当有IO的时候提醒一下，切到其他的地方去
@asyncio.coroutine
def task(task_id,seconds):
    print("%s is start"%task_id)
    yield from asyncio.sleep(seconds)  #自动检测IO，  #遇到IO就切，并且保存状态
    print("%s id end" %task_id)

tasks = [
    task(task_id="任务1",seconds=3),
    task(task_id="任务2",seconds=2),
    task(task_id="任务3",seconds=1),
]
loop = asyncio.get_event_loop()  #创建事件循环
loop.run_until_complete(asyncio.wait(tasks))  #运行事件循环，直到任务完成
loop.close()  #一旦任务结束，就获取到任务的结果

2、但asyncio模块只能发tcp级别的请求，不能发http协议，因此，在我们需要发送http请求的时候，需要我们自定义http报头

 import requests
 import asyncio
 import uuid
 User_Agent='Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36'

 def parse_page(res):
     with open("%s.html"%uuid.uuid1(),"wb") as f:
         f.write(res)

 def get_pager(host,port=80,url="/",ssl=False,callback=parse_page):

     #1、建立连接
     if ssl:
         port = 443
     print("下载：https:%s:%s:%s"%(host,port,url))
     recv,send = yield from asyncio.open_connection(host=host,port=port,ssl=ssl)

     #2、封装请求头
     request_headers="""GET %s HTTP/1.0\r\nHost: %s\r\nUser-Agent: %s\r\n\r\n""" %(url,host,User_Agent)# http / 1.0省去了拼接太多的东西
     request_headers=request_headers.encode('utf-8')

     #3、发送请求头
     send.write(request_headers) #套接字不能发字符串，要发bytes
     yield from send.drain() # 发送请求头 #遇到IO就切，并且保存状态
     #4、接收响应头
     # recv.read()  # 接收全部的，但是不能区分响应头和响应体
     # recv.readline()  # 一次收一行，但是你也不确定一次收几行,所以搞个循环
     while True:
         line = yield from recv.readline()
         if line == b'\r\n':  # 最后一行是\r\n,就结束了
             break
     #5、接受响应体
     text = yield from recv.read()
     #6、调用回调函数，完成解析功能
     #看一下效果，保存起来，吧返回的值给一个回调函数
     callback(text)
     #7、关闭连接
     send.close()
     # 三次握手建立好之后，一定是四次之后才断开连接
     # 发送端决定接受数据的什么时候关闭，
     # 没有recv.close()

 if __name__ == '__main__':
     tasks = [
         get_pager(host='www.baidu.com', url='/s?wd=唐诗三百首', ssl=True),
         get_pager(host='www.cnblogs.com', url='/haiyan123/p/7445542.html', ssl=True)
     ]
     loop = asyncio.get_event_loop()
     loop.run_until_complete(asyncio.wait(tasks))
     loop.close()

爬虫应用asyncio模块

3、自定义http报头多少有点麻烦，于是有了aiohttp模块，专门帮我们封装http报头，然后我们还需要用asyncio检测IO实现切换

 import aiohttp
 import asyncio

 @asyncio.coroutine
 def get_page(url):
     print('GET:%s' %url)
     response=yield from aiohttp.request('GET',url)

     data=yield from response.read()

     print(url,data)
     response.close()
     return 1

 tasks=[
     get_page('https://www.python.org/doc'),
     get_page('https://www.cnblogs.com/linhaifeng'),
     get_page('https://www.openstack.org')
 ]

 loop=asyncio.get_event_loop()
 results=loop.run_until_complete(asyncio.gather(*tasks))
 loop.close()

 print('=====>',results) #[1, 1, 1]

asyncio+aiohttp

4、此外，还可以将requests.get函数传给asyncio，就能够被检测了

 import requests
 import asyncio

 @asyncio.coroutine
 def get_page(func,*args):
     print('GET:%s' %args[0])
     loog=asyncio.get_event_loop()
     furture=loop.run_in_executor(None,func,*args)
     response=yield from furture

     print(response.url,len(response.text))
     return 1

 tasks=[
     get_page(requests.get,'https://www.python.org/doc'),
     get_page(requests.get,'https://www.cnblogs.com/linhaifeng'),
     get_page(requests.get,'https://www.openstack.org')
 ]

 loop=asyncio.get_event_loop()
 results=loop.run_until_complete(asyncio.gather(*tasks))
 loop.close()

 print('=====>',results) #[1, 1, 1]

asyncio+requests模块的方法

5、还有之前在协程时介绍的gevent模块

 from gevent import monkey;monkey.patch_all()
 import gevent
 import requests

 def get_page(url):
     print('GET:%s' %url)
     response=requests.get(url)
     print(url,len(response.text))
     return 1

 # g1=gevent.spawn(get_page,'https://www.python.org/doc')
 # g2=gevent.spawn(get_page,'https://www.cnblogs.com/linhaifeng')
 # g3=gevent.spawn(get_page,'https://www.openstack.org')
 # gevent.joinall([g1,g2,g3,])
 # print(g1.value,g2.value,g3.value) #拿到返回值

 #协程池
 from gevent.pool import Pool
 pool=Pool(2)
 g1=pool.spawn(get_page,'https://www.python.org/doc')
 g2=pool.spawn(get_page,'https://www.cnblogs.com/linhaifeng')
 g3=pool.spawn(get_page,'https://www.openstack.org')
 gevent.joinall([g1,g2,g3,])
 print(g1.value,g2.value,g3.value) #拿到返回值

gevent+requests

6、封装了gevent+requests模块的grequests模块

 #pip3 install grequests

 import grequests

 request_list=[
     grequests.get('https://wwww.xxxx.org/doc1'),
     grequests.get('https://www.cnblogs.com/linhaifeng'),
     grequests.get('https://www.openstack.org')
 ]

 ##### 执行并获取响应列表 #####
 # response_list = grequests.map(request_list)
 # print(response_list)

 ##### 执行并获取响应列表（处理异常） #####
 def exception_handler(request, exception):
     # print(request,exception)
     print("%s Request failed" %request.url)

 response_list = grequests.map(request_list, exception_handler=exception_handler)
 print(response_list)

grequests

7、twisted：是一个网络框架，其中一个功能是发送异步请求，检测IO并自动切换

 from twisted.web.client import getPage,defer
 from twisted.internet import reactor
 #pip install pypiwin32

 def all_done(res):  #这里的res ，接收的是所有函D:\pywin32+twisted\Twisted-17.9.0-cp36-cp36m-win_amd64.whl数的返回值，
     '''等到所有的任务都结束了才触发这个函数'''
     print(res) # #打印结果[(回调函数是否抛出异常<True,False>,回调函数的返回值),(),()]
     reactor.stop()

 def callback(res):
     print(len(res))  #obj
     return 1

 urls = [
     'http://www.baidu.com',
     'http://www.bing.com',
     'http://www.python.org',
 ]
 task = []
 for url in urls:
     obj = getPage(url.encode("utf-8"),)  #请求url页面，要传bytes类型的
     obj.addCallback(callback)  #吧结果给了回调函数
     task.append(obj)
 # defer.Deferred(task)  #创建循环，开始检测IO
 defer.DeferredList(task).addBoth(all_done)  #给所有任务绑定一个回调函数，等所有的任务都结束了以后关闭连接
 reactor.run()

twisted

8、tornado

 from tornado.httpclient import AsyncHTTPClient
 from tornado.httpclient import HTTPRequest
 from tornado import ioloop

 def handle_response(response):
     """
     处理返回值内容（需要维护计数器，来停止IO循环），调用 ioloop.IOLoop.current().stop()
     :param response:
     :return:
     """
     if response.error:
         print("Error:", response.error)
     else:
         print(response.body)

 def func():
     url_list = [
         'http://www.baidu.com',
         'http://www.bing.com',
     ]
     for url in url_list:
         print(url)
         http_client = AsyncHTTPClient()
         http_client.fetch(HTTPRequest(url), handle_response)

 ioloop.IOLoop.current().add_callback(func)
 ioloop.IOLoop.current().start()

 #发现上例在所有任务都完毕后也不能正常结束，为了解决该问题，让我们来加上计数器
 from tornado.httpclient import AsyncHTTPClient
 from tornado.httpclient import HTTPRequest
 from tornado import ioloop

 count=0

 def handle_response(response):
     """
     处理返回值内容（需要维护计数器，来停止IO循环），调用 ioloop.IOLoop.current().stop()
     :param response:
     :return:
     """
     if response.error:
         print("Error:", response.error)
     else:
         print(len(response.body))

     global count
     count-=1 #完成一次回调，计数减1
     if count == 0:
         ioloop.IOLoop.current().stop() 

 def func():
     url_list = [
         'http://www.baidu.com',
         'http://www.bing.com',
     ]

     global count
     for url in url_list:
         print(url)
         http_client = AsyncHTTPClient()
         http_client.fetch(HTTPRequest(url), handle_response)
         count+=1 #计数加1

 ioloop.IOLoop.current().add_callback(func)
 ioloop.IOLoop.current().start()

Tornado