zoukankan      html  css  js  c++  java
  • Python协程(上)

    几个概念:

    • event_loop 事件循环:程序开启一个无限的循环,程序员会把一些函数注册到事件循环上。当满足事件发生的时候,调用相应的协程函数。
    • coroutine 协程:协程对象,指一个使用async关键字定义的函数,它的调用不会立即执行函数,而是会返回一个协程对象。协程对象需要注册到事件循环,由事件循环调用。
    • task 任务:一个协程对象就是一个原生可以挂起的函数,任务则是对协程进一步封装,其中包含任务的各种状态。
    • future: 代表将来执行或没有执行的任务的结果。它和task上没有本质的区别
    • async/await 关键字:python3.5 用于定义协程的关键字,async定义一个协程,await用于挂起阻塞的异步调用接口。

    定义协程

    通过async关键字定义一个协程(coroutine),协程也是一种对象。协程不能直接运行,需要把协程加入到事件循环(loop),由后者在适当的时候调用协程。asyncio.get_event_loop方法可以创建一个事件循环,然后使用run_until_complete将协程注册到事件循环,并启动事件循环。

    import time
    import asyncio
    
    async def task(x):
        print('Waiting: ', x)
        await asyncio.sleep(x)
    
    start = time.time()
    
    coroutine = task(2)
    loop = asyncio.get_event_loop()
    loop.run_until_complete(coroutine)
    
    print('用时:', time.time()-start)
    

    创建task

    协程对象不能直接运行,在注册事件循环的时候,其实是run_until_complete方法将协程包装成为了一个任务(task)对象。所谓task对象是Future类的子类。保存了协程运行后的状态,用于未来获取协程的结果。

    import asyncio
    import time
    
    async def task(x):
        print('Waiting: ', x)
        await asyncio.sleep(x)
    
    
    start = time.time()
    
    coroutine = task(2)
    loop = asyncio.get_event_loop()
    task = loop.create_task(coroutine)      # task = asyncio.ensure_future(coroutine)
    print(task)
    loop.run_until_complete(task)
    print(task)
    print('用时:', time.time() - start)
    

    创建task后,task在加入事件循环之前是pending状态,执行之后是finished状态。

    asyncio.ensure_future(coroutine) 和loop.create_task(coroutine)
    都可以创建一个task,run_until_complete的参数是一个futrue对象。当传入一个协程,其内部会自动封装成task,task是Future的子类。isinstance(task, asyncio.Future)将会输出True。

    绑定回调

    绑定回调,在task执行完毕的时候可以获取执行的结果,回调的最后一个参数是future对象,通过该对象可以获取协程返回值。如果回调需要多个参数,可以通过偏函数导入。

    import time
    import asyncio
    
    async def task(x):
        print('Waiting: ', x)
        await asyncio.sleep(x)
        return 'Done after {}s'.format(x)
    
    def callback(future):
        print('Callback: ', future.result())
    
    
    coroutine = task(2)
    loop = asyncio.get_event_loop()
    task = asyncio.ensure_future(coroutine)
    task.add_done_callback(callback)
    loop.run_until_complete(task)
    

    coroutine执行结束时候会调用回调函数。并通过参数future获取协程执行的结果。我们创建的task和回调里的future对象,实际上是同一个对象。

    future 与 result

    回调中我们使用了future对象的result方法。前面不绑定回调的例子中,我们可以看到task有fiinished状态。在那个时候,可以直接读取task的result方法。

    async def task(x):
        print('Waiting {}'.format(x))
        return 'Done after {}s'.format(x)
    
    coroutine = task(2)
    loop = asyncio.get_event_loop()
    task = asyncio.ensure_future(coroutine)
    loop.run_until_complete(task)
    
    # task.result()是协程对象的返回值
    print('Task result: {}'.format(task.result()))
    

    阻塞和await

    使用async可以定义协程对象,使用await可以针对耗时的操作进行挂起,就像生成器里的yield一样,函数让出控制权。协程遇到await,事件循环将会挂起该协程,执行别的协程,直到其他的协程也挂起或者执行完毕,再进行下一个协程的执行。

    耗时的操作一般是一些IO操作,例如网络请求,文件读取等。我们使用asyncio.sleep函数来模拟IO操作。协程的目的也是让这些IO操作异步化。

    import asyncio
    import time
    
    async def task(x):
        print('Waiting: ', x)
        await asyncio.sleep(x)
        return 'Done after {}s'.format(x)
    
    start = time.time()
    
    coroutine = task(2)
    loop = asyncio.get_event_loop()
    task = asyncio.ensure_future(coroutine)
    loop.run_until_complete(task)
    
    print('Task result: ', task.result())
    print('Time: ', time.time() - start)
    

    在 sleep的时候,使用await让出控制权。即当遇到阻塞调用的函数的时候,使用await方法将协程的控制权让出,以便loop调用其他的协程。现在我们的例子就用耗时的阻塞操作了。

    并发和并行

    asyncio实现并发,就需要多个协程来完成任务,每当有任务阻塞的时候就await,然后其他协程继续工作。创建多个协程的列表,然后将这些协程注册到事件循环中。

    import asyncio
    import time
    
    async def task(x):
        print('Waiting: ', x)
        await asyncio.sleep(x)
        return 'Done after {}s'.format(x)
    
    start = time.time()
    
    coroutine1 = task(1)   # <coroutine object task at 0x000001E583341258>
    coroutine2 = task(2)
    coroutine3 = task(4)
    
    loop = asyncio.get_event_loop()
    tasks = [                             # 创建任务
        asyncio.ensure_future(coroutine1),
        asyncio.ensure_future(coroutine2),
        asyncio.ensure_future(coroutine3)
    ]
    loop.run_until_complete(asyncio.wait(tasks))
    
    for task in tasks:
        print('Task result: ', task.result())
        
    print('Time: ', time.time() - start)
    
    # 当任务比较多的时候,可以使用列表生成式,效果是一样的。
    import asyncio
    import time
    
    async def task(x):
        print('Waiting: ', x)
        await asyncio.sleep(x)
        return 'Done after {}s'.format(x)
    
    start = time.time()
    
    loop = asyncio.get_event_loop()
    tasks = [asyncio.ensure_future(task(i)) for i in [1,2,4]]
    loop.run_until_complete(asyncio.wait(tasks))
    
    for task in tasks:
        print('Task result: ', task.result())
    
    print('Time: ', time.time() - start)
    

    使用aysncio实现了并发。asyncio.wait(tasks) 也可以使用 asyncio.gather(*tasks) ,前者接受一个task列表,后者接收一堆task。

  • 相关阅读:
    Delphi编译器属性(特别修饰符Ref,Unsafe,Volatile,Weak)
    .netcore dapr微服务入门
    Net WebApi一个简单的Token验证
    发布订阅和观察者模式
    NET Core创建Windows服务
    jquery.barrager.js弹幕实现
    跨平台中的RN、Flutter,服务端GraphQL、Serverless,Node和Electron
    分布式系统与高并发高可用
    11 个 Linux 命令
    接口幂等性
  • 原文地址:https://www.cnblogs.com/cnkai/p/7642775.html
Copyright © 2011-2022 走看看