爬虫.多线程爬虫 和 单线程+多任务异步协程

• 协程
  • 在函数（特殊的函数）定义的时候，如果使用了async修饰的话，则该函数调用后会返回一个协程对象，并且函数内部的实现语句不会立即执行
• 任务对象
  • 任务对象就是对协程对象的进一步封装。任务对象==高级的协程对象==特殊的函数
  • 任务对象时必须要注册到事件循环对象中
  • 给任务对象绑定回调：爬虫的数据解析中
• 事件循环
  • 把事件循环当做是一个循环的容器，容器中必须存放任务对象
  • 当启动事件循环对象后，则事件循环对象会对其内部存储任务对象进行异步的执行
• aiohttp：支持异步网络请求的模块

先用Flask模拟一个网页：

from flask import Flask
import time

app = Flask(__name__)


@app.route('/bobo')
def index_bobo():
    time.sleep(2)
    return 'Hello bobo'

@app.route('/jay')
def index_jay():
    time.sleep(2)
    return 'Hello jay'

@app.route('/tom')
def index_tom():
    time.sleep(2)
    return 'Hello tom'

if __name__ == '__main__':
    app.run(threaded=True)

1. 多进程爬虫：

from multiprocessing.dummy import Pool
import requests
import time
start = time.time()
urls = [
    'http://localhost:5000/jay',
    'http://localhost:5000/bobo',
    'http://localhost:5000/tom',

]
def get_request(url):
    page_text = requests.get(url).text
    print(page_text)

pool = Pool(5)
pool.map(get_request, urls)

print('总耗时：', time.time() - start)

 

2. 单线程+多任务异步协程爬虫

2.1 协程的简单实现：

import asyncio
def callback(task):#作为任务对象的回调函数
    print('i am callback and ',task.result())

async def test():
    print('i am test()')
    return 'bobo'

c = test()
#封装了一个任务对象
task = asyncio.ensure_future(c)
task.add_done_callback(callback)
#创建一个事件循环的对象
loop = asyncio.get_event_loop()
loop.run_until_complete(task)

2.2单线程+多任务异步协程爬虫

import requests
import aiohttp
import time
import asyncio
s = time.time()
urls = [
    'http://127.0.0.1:5000/bobo',
    'http://127.0.0.1:5000/jay'
]

# 协程
async def get_request(url):
   async with aiohttp.ClientSession() as s:
       async with await s.get(url=url) as response:
           page_text = await response.text()
           print(page_text)
   return page_text

tasks = []
for url in urls:
    # 协程:c
    c = get_request(url)

    # 任务对象:task
    task = asyncio.ensure_future(c)
    tasks.append(task)

# 事件循环:loop
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

print(time.time()-s)