Python asyncio库的学习和使用

由于要找工做，把以前本身搞的爬虫整理一下，没有项目经验真蛋疼，只能作这种水的不行的东西。。。T  T，但愿找工做能有好结果。

以前爬虫使用的是requests+多线程/多进程，后来随着前几天的深刻了解，才发现，对于爬虫来讲，真正的瓶颈并非CPU的处理速度，而是对于网页抓取时候的往返时间，由于若是采用requests+多线程/多进程，他自己是阻塞式的编程，因此时间都花费在了等待网页结果的返回和对爬取到的数据的写入上面。而若是采用非阻塞编程，那么就没有这个困扰。这边首先要理解一下阻塞和非阻塞的区别

 

1.阻塞调用是指调用结果返回以前，当前线程会被挂起（线程进入非可执行状态，在这个状态下，CPU不会给线程分配时间片，即线程暂停运行）。函数只有在获得结果以后才会返回。

2.对于非阻塞则不会挂起，直接执行接下去的程序，返回结果后再回来处理返回值。

 

python 3.4开始就支持异步IO编程，提供了asyncio库，可是3.4中采用的是@asyncio.coroutine和yield from这和原来的generator关键字yield很差区分，在3.5中，采用了async(表示携程)和await关键字，这样就好区分多了。

写这篇博客的目的在于，网上看了一堆资料，本身仍是没有理解如何进行asyncio的编程，用到本身代码里时候，仍是有各类错误，所以打算看一下asyncio的官方手册并好好梳理一下，但愿时间的来的及~

https://docs.python.org/3/library/asyncio.html

这边用一个简单的官方例子来讲明async和await的执行顺序。

import asyncio

async def compute(x, y):
    print("Compute %s + %s ..." % (x, y))
    await asyncio.sleep(1.0)
    return x + y

async def print_sum(x, y):
    result = await compute(x, y)
    print("%s + %s = %s" % (x, y, result))

loop = asyncio.get_event_loop()
loop.run_until_complete(print_sum(1, 2))
loop.close()

若是不使用async和await,这个程序的运行顺序也很好理解

1.print_sum(1,2)将参数1,2传递给函数print_sum

2.先执行第一句，result = compute(x,y),

3.将1,2传递给compute函数，compute函数收到参数

4.先执行 print("Compute %s + %s ..." % (x, y))打印出Compute 1 + 2 ...

5.执行sleep（1.0）程序挂起一秒

6.返回1+2的值3

7.print_sum的result收到返回值3，执行print("%s + %s = %s" % (x, y, result))，打印出1 + 2 = 3

8.程序结束

若是采用异步的话，他执行顺序是怎么样的呢？

下图是他官方文档的说明：

 

要理解上图，首先咱们要理解Event_loop，feture,task等概念，详细的能够参考官方文档或者http://my.oschina.net/lionets/blog/499803

 首先get_event_loop()方法让咱们获得一个消息环，event loop对象包括两部分：event和loop,event负责I/O时间通知二loop负责循环处理I/O通知并在就绪时调用回调。

event loop 内部维护着两个容器：_ready 和 _scheduled。类型分别是 deque 和 list。_ready 表明已经能够执行，_scheduled 表明计划执行。_scheduled 中的 handle 是能够 cancel 的。

要理解task，首先须要理解future对象（via http://my.oschina.net/lionets/blog/499803)

class asyncio.Future(*, loop=None) 是对一个可调用对象的异步执行控制或者说代理的封装。所以具备以下方法：

• cancel()
• cancelled()
• done()
• result()
• exception()
• add_done_callback(fn)
• remove_done_callback(fn)
• set_result(result)
• set_exception(exception)

注意 Future 并不包含可执行对象的本体，他只保存状态、结果、额外的回调函数这些东西。这也是上面称之为代理的缘由。由于实际的调用过程是在 event loop 里发生的，event loop 负责在异步执行完成后向 future 对象写入 result 或 exception。这是异步任务的基本逻辑。

future 实例有三种状态：

• PENDING
• CANCELLED
• FINISHED

初始状态为 PENDING，当调用 cancel() 方法时会当即进入 CANCELLED 状态并 schedule callbacks。当被调用 set_result()时会进入 FINISHED 状态，并 schedule callbacks。固然两种状况下传入 callback 的参数会不一样。

Task是 Future 的子类。由于 Future 没有保存其相关可执行对象的信息，咱们 schedule the execution of a coroutine 这件事通常是经过 Task 对象来作的。 Task 提供了一种机制用于当 future 完成时唤醒父级协程。即为当 await future 时，task 对象会将此 future 保存到 _fut_waiter 对象中，并为其添加一个名为_wake_up() 的回调。

继续分析上面这段代码，首先async def建立一个coroutine object，get_event_loop建立一个消息环，接下去，run_until_complete()接受coroutine object对象，经过隐式转换（ensure_future())将其包装成一个future,这边是一个task对象（内部实现机制我其实也并非很是肯定，大体是这样，好比如何从future转换成task??）

1.get_event_loop()建立消息环

2.print_sum返回一个携程对象（coroutine object）

3.print_sum（1,2）接受参数

4.result = await compute(x,y),此时程序挂起，直接调用compute(1,2)

5.打印出Compute 1 + 2 ...

6.执行sleep(1.0) 因为使用await，因此sleep(1.0)被挂起，直接执行下一句

7.这边因为只有一个task，即print_sum(1,2),所以没有其余task能够执行，因此result等待compute（x，y)的返回值，等待1秒之后，返回1+2的值3

而后执行print("%s + %s = %s" % (x, y, result))

其实上面的程序可能还不能很明白async def和 await的调用过程究竟是怎么样，稍微修改一下上面的程序就能更加明白他的执行过程了。

import asyncio

async def compute(x, y):
    print("Compute %s + %s ..." % (x, y))
    await asyncio.sleep(10.0)
    return x + y

async def print_sum(x, y):
    result = await compute(x, y)
    print("%s + %s = %s" % (x, y, result))

loop = asyncio.get_event_loop()
tasks = [print_sum(1,2),print_sum(3,4)]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

把代码修改为这样，其余不变，多了一个task，为了更加直观，我把sleep(1.0)改为了sleep(10.0)

此时程序的执行结果是

Compute 3 + 4 ...
Compute 1 + 2 ...
暂停10秒左右
3 + 4 = 7
1 + 2 = 3

很是须要注意的就是这边暂停的时间，是10秒左右，不是20秒，因此他执行顺序是对于task

先执行print_sum(3,4）（这边tasks额执行顺序我不是很是理解，我多加了不少task测验，发现都是从第二个开始执行，而后最后执行第一个task，没懂是为何）将3,4扔给compute，在compute中，sleep(10.0)挂起，此时不等待sleep(10.0)执行完毕，直接执行tasks中的另外一个task，print_sum（1,2），将1,2扔给compute，在compute中，sleep(10.0)挂起，因为已经没有其余的task，因此等待第一个sleep（10.0)执行完毕之后返回3+4的结果为7，执行result = await compute(3, 4)后面的程序，即打印出3 + 4 = 7执行完毕之后，第二个sleep（10.0）也差很少返回了，所以回到原来挂起的result = await compute(1, 2)，打印出1 + 2 = 3.全部task执行完毕，loop complete而且close。

这样整个async def 和await的执行流程就比较清楚了。