asyncio基础篇02

本节将的是loop基本用法，其实在一般情况下是不会对loop进行操作，而对于框架的搭建者，要更精细的控制loop 是需要对loop进行更进一步的理解的。

事件循环是每个 asyncio 应用的核心。 事件循环会运行异步任务和回调，执行网络 IO 操作，以及运行子进程。

loop.call_soon(callback, *args, context=None)

安排在下一次事件循环的迭代中使用 args 参数调用 callback 。

回调按其注册顺序被调用。每个回调仅被调用一次。
返回一个能用来取消回调的 asyncio.Handle 实例。

loop.call_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()

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()

loop.call_later(delay, callback, *args, context=None)

此方法同 call_soon 一样，可将普通函数作为任务放到事件循环里，不同之处在于此方法可延时执行，第一个参数为延时时间
delay的时间计算是从loop循环开始

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()

运行结果：
[workA]  start
[hello]  Hello, Kitty
[workB]  start
[hello]  Hello, Jerry
[workA]  stop
[hello]  Hello, Tom
[workB]  stop

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()

运行结果和上面的相同

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(1)
        print('----------',name)  # 阻塞 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()

运行结果：
lalalalalalalala
one start
lalalalalalalala
---------- one
one end
one ok
two start
two ok