(python篇)协程的简单使用

seaeress

已于 2023-01-14 14:28:07 修改

阅读量1.1k

点赞数

分类专栏： python 文章标签： python

于 2022-12-17 15:50:58 首次发布

本文链接：https://blog.csdn.net/seaeress/article/details/128353006

版权

python 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、协程

协程

又称微线程(纤程)，是一种用户态的轻量级线程
子程序

在所有的语言中都是层级调用的，比如A中调用B，B在执行过程中调用C，C执行完返回，B执行完返回，最后是A执行完毕。这是通过栈实现的，一个函数就是一个执行的子程序，子程序的调用总是有一个入口、一次返回，调用的顺序是明确的
理解协程

线程是系统级别的，它们是由操作系统调度。
协程是程序级别的，由程序员根据需求自己调度。
我们把一个线程中的一个个函数称为子程序，那么一个子程序在执行的过程中可以中断去执行别的子程序，这就是协程。
也就是说同一个线程下的一段代码1执行执行着就中断，然后去执行另一段代码2，当再次回来执行代码1时，接着从之前的中断的位置继续向下执行
优点

a、协程极高的执行效率。
因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

b、不需要多线程的锁机制。
因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。
缺点

a、无法利用多核CPU，协程的本质是单个线程，它不能同时将多个CPU的多个核心使用上，失去了标准线程使用多CPU的能力。

b、进行阻塞操作(操作IO)会阻塞整个程序

二、同步与异步

1、同步与异步的概念

前言

python由于GIL（全局锁）的存在，不能发挥多核的优势，其性能一直饱受诟病。然而在IO密集型的网络编程里，异步处理比同步处理能提升成百上千倍的效率

IO密集型就是磁盘的读取数据和输出数据非常大的时候
由于IO操作的运行时间远远大于cpu、内存运行时间，所以任务的大部分时间都是在等待IO操作完成，IO的特点是cpu消耗小，所以，IO任务越多，cpu效率越高，当然不是越多越好，有一个极限值。
同步

指完成事务的逻辑，先执行第一个事务，如果阻塞了，会一直等待，直到这个事务完成，再执行第二个事务，顺序执行
异步

是和同步相对的，异步是指在处理调用这个事务的之后，不会等待这个事务的处理结果，直接处理第二个事务去了，通过状态、通知、回调来通知调用者处理结果

三、asyncio模块

1、概述

asyncio模块

是python3.4版本引入的标准库，直接内置了对异步IO的操作
编程模式

是一个消息循环，我们从asyncio模块中直接获取一个EventLoop的引用，然后把需要执行的协程扔到EventLoop中执行，就实现了异步IO
说明

到目前为止实现协程的不仅仅只有asyncio,tornado和gevent都实现了类似功能

关键字的说明

关键字	说明
event_loop	消息循环，程序开启一个无限循环，把一些函数注册到事件循环上，当满足事件发生的时候，调用相应的协程函数
coroutine	协程对象，指一个使用async关键字定义的函数，它的调用不会立即执行函数，而是会返回一个协程对象。协程对象需要注册到事件循环，由事件循环调用
task	任务，一个协程对象就是一个原生可以挂起的函数，任务则是对协程进一步封装，其中包含了任务的各种状态
async/await	python3.5用于定义协程的关键字，async定义一个协程，await用于挂起阻塞的异步调用接口

2、开启多任务协程

Task 概念及用法

Task，是 python 中与事件循环进行交互的一种主要方式。

创建 Task，意思就是把协程封装成 Task 实例，并追踪协程的运行 / 完成状态，用于未来获取协程的结果。
Task 核心作用: 在事件循环中添加多个并发任务;

具体来说，是通过 asyncio.create_task() 创建 Task，让协程对象加入时事件循环中，等待被调度执行。

**注意:**Python 3.7 以后的版本支持 asyncio.create_task() ，在此之前的写法为 loop.create_task() ，开发过程中需要注意代码写法对不同版本 python 的兼容性。
需要指出的是，协程封装为 Task 后不会立马启动，当某个代码 await 这个 Task 的时候才会被执行。

当多个 Task 被加入一个 task_list 的时候，添加 Task 的过程中 Task 不会执行，必须要用 await asyncio.wait() 或 await asyncio.gather() 将 Task 对象加入事件循环中异步执行。
一般在开发中，常用的写法是这样的:

– 先创建 task_list 空列表;
– 然后用 asyncio.create_task() 创建 Task;

– 再把 Task 对象加入 task_list ;

– 最后使用 await asyncio.wait 或 await asyncio.gather 将 Task 对象加入事件循环中异步执行。

import asyncio

async def run(url):
    print('异步任务开始')
    await asyncio.sleep(2)
    print('异步任务结束')
    return url

def call_back(f):
    print('返回值为：', f.result())

if __name__ == '__main__':
    loop = asyncio.get_event_loop()  # 创建事件循环
    task_list = []
    for url in ['百度', '阿里', '京东', '爱奇艺']:
        coroutine = run(url)
        task = loop.create_task(coroutine)  # 创建任务
        task.add_done_callback(call_back)
        task_list.append(task)
    loop.run_until_complete(asyncio.wait(task_list))

3、返回值

asyncio.wait和asyncio.gather的异同

相同:从功能上看， asyncio.wait 和 asyncio.gather 实现的效果是相同的，都是把所有 Task 任务结果收集起来。

不同: asyncio.wait 会返回两个值: done 和 pending ， done 为已完成的协程 Task ， pending 为超时未完成的协程 Task ，需通过 future.result 调用 Task 的 result ;
而asyncio.gather 返回的是所有已完成 Task 的 result ，不需要再进行调用或其他操作，就可以得到全部结果。

wait返回值

import asyncio
import random

async def run(i):
    print('协程开始', i)
    await asyncio.sleep(random.randint(1, 5))
    print('协程结束', i)
    return i

async def main():
    tasks = []  # 装当前task任务
    for i in range(1, 5):
        task = asyncio.get_event_loop().create_task(run(i))
        tasks.append(task)
    done, pending = await asyncio.wait(tasks)
    # 循环以及完成任务的协程 获取返回值
    for d in done:
        print('返回值', d.result())

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

wait外部返回值

import asyncio
import random

async def run(i):
    print('协程开始', i)
    await asyncio.sleep(random.randint(1, 5))
    print('协程结束', i)
    return i

async def main():
    tasks = []  # 装当前task任务
    for i in range(1, 5):
        task = asyncio.create_task(run(i))
        tasks.append(task)
    return await asyncio.wait(tasks)

if __name__ == '__main__':
    done, pending = asyncio.run(main())
    # 循环以及完成任务的协程 获取返回值
    for d in done:
        print('返回值', d.result())

gather返回值

import asyncio
import random

async def run(i):
    print('协程开始', i)
    await asyncio.sleep(random.randint(1, 5))
    print('协程结束', i)
    return i

async def main():
    tasks = []  # 装当前task任务
    for i in range(1, 5):
        task = asyncio.get_event_loop().create_task(run(i))
        tasks.append(task)
    done = await asyncio.gather(*tasks)
    # 循环以及完成任务的协程 获取返回值
    for d in done:
        print('返回值', d)

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

gather外部返回值

import asyncio
import random

async def run(i):
    print('协程开始', i)
    await asyncio.sleep(random.randint(1, 5))
    print('协程结束', i)
    return i

async def main():
    tasks = []  # 装当前task任务
    for i in range(1, 5):
        task = asyncio.get_event_loop().create_task(run(i))
        tasks.append(task)
    return await asyncio.gather(*tasks)


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    done = loop.run_until_complete(main())
    # 循环以及完成任务的协程 获取返回值
    for d in done:
        print('返回值', d)

使用回调函数获取返回值

import asyncio
import random

async def run(i):
    print('协程开始', i)
    await asyncio.sleep(random.randint(1, 5))
    print('协程结束', i)
    return i

def call_back(f):
    print('返回值------', f.result())

async def main():
    tasks = []  # 装当前task任务
    for i in range(1, 5):
        task = asyncio.get_event_loop().create_task(run(i))
        task.add_done_callback(call_back)
        tasks.append(task)
    return await asyncio.gather(*tasks)


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    done = loop.run_until_complete(main())
    # 循环以及完成任务的协程 获取返回值
    for d in done:
        print('返回值', d)