Python asyncio 异步编程（二）

排定任务

排定 task / future 在事件循环中的执行顺序，也就是对应的协程先执行哪个，遇到 IO 阻塞时，CPU 转而运行哪个任务，这是我们在进行异步编程时的一个需求。前文所示的多任务程序中，事件循环里的任务的执行顺序由 asyncio.ensure_future / loop.create_task 和 asyncio.gather / asyncio.wait 排定

1、loop.run_soon

将普通函数作为任务加入事件循环并排定执行顺序。一个小例子：

import asyncio
import time

def hello(name):          # 普通函数
    print('[hello] Hello, {}'.format(name))

async def work(t, name):  # 协程函数
    print('[work]  start', name)
    await asyncio.sleep(t)
    print('[work]  {} after {}s stop'.format(name, t))

def main():
    loop = asyncio.get_event_loop()         # 创建事件循环
    asyncio.ensure_future(work(1, 'A'))     # 向事件循环中添加任务（第 1 个执行
    # call_soon 将普通函数当作 task 加入到事件循环并排定执行顺序
    # 该方法的第一个参数为普通函数名字，普通函数的参数写在后面          （第 2 个执行
    loop.call_soon(hello, 'Tom')
    loop.create_task(work(2, 'B'))          # 向事件循环中添加任务（第 3 个执行
    # 阻塞启动事件循环，顺便再添加一个任务                           （第 4 个执行
    loop.run_until_complete(work(3, 'C'))

if __name__ == '__main__':
    main()

运行结果：

$ python3 a.py
[work]  start A
[hello] Hello, Tom
[work]  start B
[work]  start C
[work]  A after 1s stop
[work]  B after 2s stop
[work]  C after 3s stop

2、再议 loop.stop

此方法停止事件循环之前，每个任务都会获得一次执行机会，修改前文的代码如下：

import asyncio
import time

def hello(name):            # 普通函数
    print('[hello] Hello, {}'.format(name))

def stop(loop):             # 普通函数
    # 事件循环的 stop 方法会停止全部任务后结束事件循环
    # 在停止前，每个任务都将运行一次，直到遇到 IO 阻塞
    # 可以尝试将下面这行代码放到任意普通函数和协程函数的任意位置执行来查看区别
    loop.stop()

async def work(t, name):    # 协程函数
    print('[work]  start', name)
    await asyncio.sleep(t)
    print('[work]  {} after {}s stop'.format(name, t))

def main():
    loop = asyncio.get_event_loop()
    asyncio.ensure_future(work(1, 'A'))     # 第 1 个执行
    loop.call_soon(hello, 'Tom')            # 第 2 个执行
    # 这个任务虽然是第 3 个执行，但要等待每个任务执行一次之后才会 stop
    loop.call_soon(stop, loop)              # 第 3 个执行
    loop.create_task(work(2, 'B'))          # 第 4 个执行
    # 为了让 run.stop 方法起作用
    # 这里使用 run_forever 方法无限运行事件循环，直到 run.stop 执行
    loop.run_forever()

if __name__ == '__main__':
    main()

运行结果：

$ python3 a.py
[work]  start A
[hello] Hello, Tom
[work]  start B

3、loop.call_later

此方法同 call_soon 一样，可将普通函数作为任务放到事件循环里，不同之处在于此方法可延时执行，第一个参数为延时时间，举例如下：

import asyncio
import functools

def hello(name):            # 普通函数
    print('[hello]  Hello, {}'.format(name))

async def work(t, name):    # 协程函数
    print('[work{}]  start'.format(name))
    await asyncio.sleep(t)
    print('[work{}]  stop'.format(name))

def main():
    loop = asyncio.get_event_loop()
    asyncio.ensure_future(work(1, 'A'))         # 任务 1
    loop.call_later(1.2, hello, 'Tom')          # 任务 2
    loop.call_soon(hello, 'Kitty')              # 任务 3
    task4 = loop.create_task(work(2, 'B'))      # 任务 4
    loop.call_later(1, hello, 'Jerry')          # 任务 5
    # 这个方法的参数其实无所谓，有就行，但参数须为 future / task
    loop.run_until_complete(task4)

if __name__ == '__main__':
    # 毫无疑问，这五个任务在一个事件循环里是顺序执行，遇到阻塞执行下一个
    # 首先执行任务一，打印一行后阻塞 1 秒，执行任务二
    # 任务二是 call_later 1.2 秒，就相当于一个 1.2 秒的 asyncio.sleep
    # 注意，call_later 这个延时 1.2 秒是事件循环启动时就开始计时的
    # 任务二阻塞，执行任务三，这个简单，打印一行就完事儿
    # 接着执行任务四，打印一行后阻塞 2 秒
    # 接着执行任务五，还是 call_later 1 秒，阻塞
    # 以上是五个任务第一轮的执行情况

    # 第二轮开始前，CPU 一直候着，现在还有 4 个任务，任务三已完成
    # 第一个发出执行信号的是任务五，它只阻塞 1 秒
    # 上面已经说了，这个 1 秒是从事件循环启动时开始算
    # 所以这个阻塞肯定比任务一的阻塞 1 秒先结束
    # CPU 执行完任务五，任务一也阻塞结束了，执行之
    # 然后是任务二，最后是任务四
    # 第二轮打印了 4 行，全部任务完成，停止事件循环
    main()

运行结果：

$ python3 a.py
[workA]  start
[hello]  Hello, Kitty
[workB]  start
[hello]  Hello, Jerry
[workA]  stop
[hello]  Hello, Tom
[workB]  stop

4、loop.call_at & loop.time

• call_soon 立刻执行，call_later 延时执行，call_at 在某时刻执行
• loop.time 就是事件循环内部的一个计时方法，返回值是时刻，数据类型是 float

修改上面的代码如下，加了一行改了两行而已：

import asyncio
import functools

def hello(name):            # 普通函数
    print('[hello]  Hello, {}'.format(name))

async def work(t, name):    # 协程函数
    print('[work{}]  start'.format(name))
    await asyncio.sleep(t)
    print('[work{}]  stop'.format(name))

def main():
    loop = asyncio.get_event_loop()
    start = loop.time()                         # 事件循环内部时刻
    asyncio.ensure_future(work(1, 'A'))         # 任务 1
    # loop.call_later(1.2, hello, 'Tom')
    # 上面注释这行等同于下面这行
    loop.call_at(start+1.2, hello, 'Tom')       # 任务 2
    loop.call_soon(hello, 'Kitty')              # 任务 3
    task4 = loop.create_task(work(2, 'B'))      # 任务 4
    # loop.call_later(1, hello, 'Jerry')
    # 上面注释这行等同于下面这行
    loop.call_at(start+1, hello, 'Jerry')       # 任务 5
    # 这个方法的参数其实无所谓，有就行，但参数须为 future / task
    loop.run_until_complete(task4)

if __name__ == '__main__':
    main()

运行结果与 3 完全一致，不再展示

这三个 call_xxx 方法的作用都是将普通函数作为任务排定到事件循环中，返回值都是 asyncio.events.TimerHandle 实例，它们不是 future ，不能作为 loop.run_until_complete 的参数

5、asyncio.lock 协程锁

协程锁通常使用在子协程中，其作用是将协程内部的一段代码锁住，直到这段代码运行完毕解锁。协程锁的固定用法是使用 async with 创建协程锁的上下文环境，将代码块写入其中，示例如下：

import asyncio

l = []
lock = asyncio.Lock()   # 协程锁

async def work(name):
    print('lalalalalalalala')     # 打印此信息是为了测试协程锁的控制范围
    # 这块儿加个锁，第一次调用该协程，运行到这个语句块，上锁
    # 当语句块结束后解锁，开锁前该语句块不可被运行第二次
    # 如果上锁后有其它任务调用了这个协程函数，运行到这步会被阻塞，直至解锁
    # with 是普通上下文管理器关键字，async with 是异步上下文管理器关键字
    # 能够使用 with 关键字的对象须有 __enter__ 和 __exit__ 方法
    # 能够使用 async with 关键字的对象须有 __aenter__ 和 __aexit__ 方法
    # async with 会自动运行 lock 的 __aenter__ 方法，该方法会调用 acquire 方法上锁
    # 在语句块结束时自动运行 __aexit__ 方法，该方法会调用 release 方法解锁
    # 这和 with 一样，都是简化 try ... finally 语句
    async with lock:
        print('{} start'.format(name))  # 头一次运行该协程时打印
        if 'x' in l:                    # 如果判断成功
            return name                 # 直接返回结束协程，不再向下执行
        await asyncio.sleep(0); print('----------')  # 阻塞 0 秒，切换协程
        l.append('x')
        print('{} end'.format(name))
        return name

async def one():
    name = await work('one')
    print('{} ok'.format(name))

async def two():
    name = await work('two')
    print('{} ok'.format(name))

def main():
    loop = asyncio.get_event_loop()
    tasks = asyncio.wait([one(), two()])
    loop.run_until_complete(tasks)

if __name__ == '__main__':
    main()

运行结果：

$ python3 async_lock.py
lalalalalalalala
one start
lalalalalalalala
----------
one end
one ok
two start
two ok