python协程和任务

最新推荐文章于 2023-01-29 22:33:23 发布
最新推荐文章于 2023-01-29 22:33:23 发布
阅读量277 收藏 3
点赞数
分类专栏： python 文章标签： python 协程 asyncio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuanzhoulvpi/article/details/119798810
版权

背景

之前我写过多线程、多进程难道现在不够用么，怎么还要写协程呢？

这样吧，我们按照需求来：

  1. 之前我们因为涉及到大量的计算机本地的I/O处理，于是我们使用线程；

  2. 之前我们因为涉及到大量的计算机本地的CPU高负荷的计算，于是为了突破python的单个cpu使用问题，我们使用进程；

  3. 这一次因为很多cpu计算和I/O处理都是在远程的服务器中（比如我们经常遇到的调用云端数据库、我们对某个网站爬虫），我们为了使用对云端的服务器保持并发的话，那我们就可以不使用线程和进程来完成我的并发操作，因为多线程和多进程是很浪费我们本地计算机的cpu和内存资源，使用多协程就可以使得我们再不浪费本地计算机资源的情况下，还能做到并发操作。这样的操作难道不香么。

具体案例

我自己有个数据看板，数据看板上的数据，需要不断的刷新，大概是每隔一小时刷新一次，怎么刷新呢，大概是有30个sql文件，这个30个文件是需要被执行，按道理来说，我有两种方案：

  1. 第一种就是使用for循环，一个一个的执行sql，但是这样太慢了，如果遇到有的sql运行卡住了，那后面的sql文件可能就执行不了了，可能30个sql文件一个小时都还没刷新完，下一次的刷新任务又启动了，这样肯定不可取。

  2. 第二种方法就是使用多进程，对30多个sql进行多进程处理，也就是30个多个sql文件同时运行，emmmmm，如果使用这种方法，我感觉我的数据库账号可能会被吊销，还有可能把数据库搞崩溃，这个责任我可担不起。

  3. 第三种也就是我现在使用的方法，就是使用多进程处理，但是我设置30个sql在每次执行的时候，同时最高有4个sql在执行，这样我防止单个sql被卡住了，不会影响后面的sql执行；同时服务器的压力也不高；

方法3确实很不错，目前已经稳定运行2个多月了，目前没有出现任何问题；但是我后来在知道协程的时候，才发现方法3依然可以被优化。被优化的地方主要是在于当计算机本地的多进程在进行切换的时候，开销很大，造成本地的计算机性能浪费。

为什么协程就是开销小呢，因为协程在python的实现中，实际上还是在一个线程中运行，只是使用了很巧妙的方法来实现。既然协程的异步请求这么有优势，为什么不使用它呢，接下来开始介绍

协程入门

part1_单个协程

下面的代码就是一个最简单的协程代码，先打印出第一个'hello',然后延迟2秒以后，在打印出'world'。

import asyncio
import datetime

# 小demo
# part 1
async def main():
    """
    part 1 简单介绍一下异步
    :return:
    """
    print('hello')
    await asyncio.sleep(2)
    print('world')

if __name__ == '__main__':
    asyncio.run(main())
    # asyncio.run(main2())
    # asyncio.run(main3())
    # asyncio.run(main4())
    # asyncio.run(main5())
    # asyncio.run(main6())
    # asyncio.run(main7())

part2_多个协程运行

需要注意的是协程函数都是使用async def 定义的，另外使用异步函数的时候，需要在异步函数前面加上await，下面这段代码首先是：先定义一个异步函数say_after,然后再使用这个函数4次。下面的代码运行时间是10秒。

import asyncio
import datetime
# part 2
async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)


async def main2():
    """
    part 2
    创建一个异步程序，需要运行say_after函数4次，怎么运行
    整个过程会运行10秒
    :return:
    """
    start_date = datetime.datetime.now()
    print(f'Start at {start_date:%Y-%m-%d %H:%M:%S}')

    await say_after(delay=1, what='hello')
    await say_after(delay=2, what='world')
    await say_after(delay=3, what='foo')
    await say_after(delay=4, what='bar')

    end_date = datetime.datetime.now()
    print(f'finished at {end_date:%Y-%m-%d %H:%M:%S}')
    print(f'total used time: {(end_date - start_date).seconds} s')
    
if __name__ == '__main__':
    # asyncio.run(main())
    asyncio.run(main2())
    # asyncio.run(main3())
    # asyncio.run(main4())
    # asyncio.run(main5())
    # asyncio.run(main6())
    # asyncio.run(main7())

part3_多个协程优雅运行

在part2中，我们为了使用say_after函数，写了4行代码，而且使用花了10s去运行，那么如果让4个协程同时运行呢？方法就是：

  1. 使用asyncio的create_task函数对我们的目标函数包装一下，创建一个task；

  2. 将4个task创建好之后，再使用await来等待4个线程完成。

下面这个代码就是一个很好的案例，整个代码运行时间是只有4秒，因为最长的协程时间就是4秒。

import asyncio
import datetime

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)


# part 3
# 因为part 2运行上面4个say_after函数需要10s，我们想要减少运行时间，方法1,
# 这个方法只是需要4s即可运行完4个say_after函数

async def main3():
    """
    # 因为part 2运行上面4个say_after函数需要10s，我们想要减少运行时间，方法1
    :return:
    """
    start_date = datetime.datetime.now()
    print(f'Start at {start_date:%Y-%m-%d %H:%M:%S}')

    task1 = asyncio.create_task(say_after(delay=1, what='hello'))
    task2 = asyncio.create_task(say_after(delay=2, what='world'))
    task3 = asyncio.create_task(say_after(delay=3, what='foo'))
    task4 = asyncio.create_task(say_after(delay=4, what='bar'))

    await task1
    await task2
    await task3
    await task4
    end_date = datetime.datetime.now()
    print(f'finished at {end_date:%Y-%m-%d %H:%M:%S}')
    print(f'total used time: {(end_date - start_date).seconds} s')
    
if __name__ == '__main__':
    # asyncio.run(main())
    # asyncio.run(main2())
    asyncio.run(main3())
    # asyncio.run(main4())
    # asyncio.run(main5())
    # asyncio.run(main6())
    # asyncio.run(main7())

part4_多个协程优雅运行

虽然part3让4个协程同时运行，减少了程序时间，但是还是不够优雅，因为我们有4个任务，竟然要写4行代码，那我们有100个任务要写100行代码？我记得好像有个东西叫列表推导式，如果我们使用列表推导式来做，那岂不是很简单？

下面这个代码里面，我使用了列表推导式来实现多个任务运行计算，说人话就是我吧asyncio的create_task放到列表里面了，然后再使用await解析这列表里面的每一个task，是不是很优雅。

import asyncio
import datetime

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)


# part 4
# part3 虽然将part2的时间从10s减少到了4s，可是写法实在是不优雅，我不喜欢
# 那么多task1，task2，task3，task4，那我要是有很多task，我要写那么多代码，实在是太难看，
# 那么这个能不能使用列表推导式呢？可以的
async def main4():
    """
    part 4比part 3就是好在了可以使用列表推导式，代码看着更加优雅
    :return:
    """
    start_date = datetime.datetime.now()
    print(f'Start at {start_date:%Y-%m-%d %H:%M:%S}')

    task = [asyncio.create_task(say_after(delay=delay, what=what)) for delay, what in
            zip([1, 2, 3, 4], ['hello', 'world', 'foo', 'bar'])]

    [await task_ for task_ in task]
    end_date = datetime.datetime.now()
    print(f'finished at {end_date:%Y-%m-%d %H:%M:%S}')
    print(f'total used time: {(end_date - start_date).seconds} s')
    
if __name__ == '__main__':
    # asyncio.run(main())
    # asyncio.run(main2())
    # asyncio.run(main3())
    asyncio.run(main4())
    # asyncio.run(main5())
    # asyncio.run(main6())
    # asyncio.run(main7())

part5_多个协程优雅运行

上面的part4已经很优雅了，将8行代码转换成了2行，主要是靠列表推导式的功劳，那么我们可不可使用更加简单的代码？

也是可以的，我们将列表推导式和create_task换成了asyncio的gather函数，这样一行代码就完成了，代码如下：

import asyncio
import datetime

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)


# part 5
# part 4 虽然使用列表，这样可以使用列表推导式，但是依然不够优雅：
# 因为我们每次都要创建一个task：create_task部分 来对say_after包装一下
# 那我们直接将这个crate_task拿到这个列表推导式外面应该怎么写
# 于是part 5来了
async def main5():
    """
    将create_task拿到列表外面（变成了gather)
    并且舍去列表推导式展开部分
    :return:
    """
    start_date = datetime.datetime.now()
    print(f'Start at {start_date:%Y-%m-%d %H:%M:%S}')

    await asyncio.gather(*[say_after(delay=delay, what=what) for delay, what in
                           zip([1, 2, 3, 4], ['hello', 'world', 'foo', 'bar'])])

    end_date = datetime.datetime.now()
    print(f'finished at {end_date:%Y-%m-%d %H:%M:%S}')
    print(f'total used time: {(end_date - start_date).seconds} s')
    
if __name__ == '__main__':
    # asyncio.run(main())
    # asyncio.run(main2())
    # asyncio.run(main3())
    # asyncio.run(main4())
    asyncio.run(main5())
    # asyncio.run(main6())
    # asyncio.run(main7())

part6_面向现实的协程和任务

上面几个part_1，2，3，4，5都是让我们可以更加优雅的解决问题，但是现实中可不是这样的，如何解决单个协程运行超时问题？如果超时了，整体的代码不能出现错误。

在下面，我创建了一个solove_timeout函数，这个函数可以控制单个协程的运行时间，如果等待时间超过3.2秒，那么这个协程将会被杀掉，但是不影响别的协程运行，代码如下：

import asyncio
import datetime

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)

# part 6
# 虽然现在part 5已经基本上很好了，足够优雅到可以让我们去解决一些比较
# 麻烦、困难的问题，但是现实生活中可不是这样的，比如说：
# 每一个函数运行时间不能过长，都有时间限制，这种情况怎么办？
# 那么part 6就是来解决这个问题的
# 我们这个了假设每一个任务运行时间不能超过3秒，并且如果一个任务超时了，
# 不能出现错误，应该直接忽略，不影响别的任务运行，那这样应该怎么做

async def solove_timeout(func, timeout=1.0, **kargs):
    try:
        await asyncio.wait_for(func(**kargs), timeout=timeout)
    except asyncio.TimeoutError:
        print("Timeout!")


async def main6():
    """
    part 6
    这里加上时间限制，如果时间超过3.2秒，那么子任务就会被取消，但是不影响别的任务
    """
    start_date = datetime.datetime.now()
    print(f'Start at {start_date:%Y-%m-%d %H:%M:%S}')

    await asyncio.gather(*[solove_timeout(say_after, timeout=3.2, delay=delay, what=what) for delay, what in
                           zip([1, 2, 3, 4], ['hello', 'world', 'foo', 'bar'])])

    end_date = datetime.datetime.now()
    print(f'finished at {end_date:%Y-%m-%d %H:%M:%S}')
    print(f'total used time: {(end_date - start_date).seconds} s')

    
if __name__ == '__main__':
    # asyncio.run(main())
    # asyncio.run(main2())
    # asyncio.run(main3())
    # asyncio.run(main4())
    # asyncio.run(main5())
    asyncio.run(main6())
    # asyncio.run(main7())

part7_面向现实的协程和任务

part6让我们的协程不会超时运行，代码稍微改一下也就可以容纳我们的代码错误，但是回到刚开始问题，如果我们限制最大的协程数量呢，应该怎么做？

我们使用asyncio.Semaphore就可以限制最大的协程并发数量。用起来也很简单，将代码包装一下就行，下面代码就是限制了协程的最大并发数量，我在代码中设置的是2，也可对不同的协程设置不同的asyncio.Semaphore限制。

import asyncio
import datetime

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)
# part 7
# part 6解决了单个子任务运行超时的问题，还有一个问题，如果限制并发的任务数量？
# 比如我有100个任务需要访问服务器（不管是爬虫还是数据库）
# 如果不作限制，这个100个任务可能会在一瞬间去访问服务器，对服务器造成很大的压力，
# 那我怎么做，可以现在并发的数量呢？
# part 7就可以解决这个问题，可以设置每个时刻，最多只有2个协程运行，
# 上一个运行完了，下一个继续补上，最终全部运行完成。

async def run_limit(func, sem, **kargs):
    async with sem:
        await func(**kargs)


async def main7():
    """
    使用asyncio.semaphore来限制最大的协程数量
    这里运行的时间是6s，因为1运行完，3开始运行，2结束的时候是4运行，最终根据最长时间的来计算，也就是6秒
    """
    start_date = datetime.datetime.now()
    print(f'Start at {start_date:%Y-%m-%d %H:%M:%S}')
    sem = asyncio.Semaphore(2)
    await asyncio.gather(*[run_limit(say_after, sem=sem, delay=delay, what=what) for delay, what in
                           zip([1, 2, 3, 4], ['hello', 'world', 'foo', 'bar'])])

    end_date = datetime.datetime.now()
    print(f'finished at {end_date:%Y-%m-%d %H:%M:%S}')
    print(f'total used time: {(end_date - start_date).seconds} s')
    
if __name__ == '__main__':
    # asyncio.run(main())
    # asyncio.run(main2())
    # asyncio.run(main3())
    # asyncio.run(main4())
    # asyncio.run(main5())
    # asyncio.run(main6())
    asyncio.run(main7())

总结

  1. 上面的代码我全部都放在了我的GitHub里面，链接为：https://github.com/yuanzhoulvpi2017/tiny_python/blob/main/asyncio_task/01_introduction.py

  2. 个人计算机本地的I/O问题用线程解决，计算机本地的CPU计算问题用进程解决，远程服务器链接（爬虫、数据库）之类的可以使用协程解决。

  3. 之前我也不懂asyncio,也都是一点一点看，如果有错误的地方，欢迎大家提出来，我继续学习改进。

yuanzhoulvpi
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
协程——asyncio.wait()警告
日常bug
04-21 7987
问题描述 使用协程弹出警告： DeprecationWarning: The explicit passing of coroutine objects to asyncio.wait() is deprecated since Python 3.8, and scheduled for removal in Python 3.11. await asyncio.wait(tasks) 原因分析： 从警告信息中得出在python3.8后直接把协程对象传给asyncio.wait()是不行的，必须封装
python多任务—协程
Yonx
09-15 1101
写在前面：花了一周的时间，对协程做了一个简单的梳理，特别是异步编程asyncio库的使用，做了详细的说明。本文主要包括的知识点有：yield生成器的复习并实现协程的功能、greenlet库实现协程、gevent库实现协程、asyncio异步协程的介绍、异步协程的创建与运行、任务的创建与运行、并发运行gather/wait/as_complete/wait_for等方法的实现、异步协程的嵌套、await关键字的理解等等，这些都是基础。由于篇幅比较长，打算分为两篇，第二篇在介绍一下asyncio的其他用法。 .
python 异步操作async和await
alex1801
01-29 1万+
asyncio是"多任务合作"模式（cooperative multitasking），允许异步任务交出执行权给其他任务，等到其他任务完成，再收回执行权继续往下执行。协程（Co-routine），也可称为微线程，或非抢占式的多任务子例程，一种用户态的上下文切换技术（通过一个线程实现代码块间的相互切换执行）。我们从asyncio模块中直接获取一个EventLoop的引用，然后把需要执行的协程扔到EventLoop中执行，就实现了异步IO。携程对象：执行携程函数 函数名()，得到的就是携程对象。
asyncio异步IO--协程（Coroutine）与任务(Task)详解
如渊的博客
12-16 1603
协程（coroutines）是通过定义函数或方法，是使用asyncio进行异步编程的首选途径。如下，是一个协程的例子：123456上例中的main方法就是我们定义的协程。代码的功能很简单：开始打印“hello”沉睡1秒打印“world”结束我们在交互环境(Python3.7)下执行以上代码，看看效果：12345678910helloworld需要注意的是：如果像执行普通代码一样直接调用main()，只会返回一个coroutine对象，
协程与任务
piglite的专栏
08-04 392
只不过一个是以单线程异步方式执行任务（期物对象的执行另当别论），一个是多线程执行任务，最后执行的结果都以序列作为容器，以任务添加顺序作为下标，有序呈现。用async def定义的函数称为协程函数，“调用”协程函数时获得的是一个协程对象（coroutine object）。期物最典型的应用场景是通过asyncio提供的run_in_executor函数，该函数将一个非异步阻塞函数通过扔到线程池中执行，同时将该函数包装为一个Future（期物）对象返回。但是Task对象的执行也得用await的方式执行。...
深入浅析python 协程与go协程的区别
01-20
进程、线程和协程 进程的定义： 进程，是计算机中已运行程序的实体。程序本身只是指令、数据及其组织形式的描述，进程才是程序的真正运行实例。 线程的定义： 操作系统能够进行运算调度的最小单位。它被包含在进程之...
python协程之动态添加任务的方法
09-19
今天小编就为大家分享一篇python协程之动态添加任务的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Python 协程并发
12-21
文章目录先行内容同步和异步阻塞和非阻塞并行和并发协作式多任务和抢占式多任务线程正文协程可等待对象一个协程并发执行的例子协程的逻辑扩展内容生成器参考 先行内容 同步和异步 同步和异步关注的发送方和接收方...
Python异步编程之协程任务的调度操作实例分析
09-18
主要介绍了Python异步编程之协程任务的调度操作,结合实例形式分析了Python异步编程中协程任务的调度相关原理、实现方法与操作注意事项,需要的朋友可以参考下
python协程基础知识（三）Asyncio 控制子任务Task与Future
coder
04-13 2995
前面已经提到怎么使用Asyncio来控制协程任务的执行，它还提供了 asyncio.Task() 类，可以在任务中使用协程。它的作用是，在同一事件循环中，多组任务被包含执行。 """ Asyncio using Asyncio.Task to execute three math function in parallel """ import asyncio @asyncio.coroutine...
python协程之动态添加任务
qq_29349715的博客
03-28 2万+
    python协程只能运行在事件循环中，但是一旦事件循环运行，又会阻塞当前任务。所以只能在当前进程中再开一个线程，这个线程的主要任务是运行事件循环，就是event_loop,因为他是一个无限循环，会阻塞当前线程。放一个自己写的demo，注释写的很详细。另外还有一点需要注意，一个事件循环中不能运行另外一个事件循环。运行结果：import asyncio from threading impor...
python多任务—协程（一）
热门推荐
weixin_41599977的博客
06-25 5万+
写在前面： 花了一周的时间，对协程做了一个简单的梳理，特别是异步编程asyncio库的使用，做了详细的说明。本文主要包括的知识点有：yield生成器的复习并实现协程的功能、greenlet库实现协程、gevent库实现协程、asyncio异步协程的介绍、异步协程的创建与运行、任务的创建与运行、并发运行gather/wait/as_complete/wait_for等方法的实现、异步协程的嵌套、aw...
python多协程完成多任务
二月的博客
10-03 2840
协程，也称用户级线程，在不开辟线程的基础上完成任务，也就是在单线程的情况下完成多任务，多个任务按照一定顺序交替执行，通俗理解只要在def里面看到只有一个yield关键字表示的就是协程。 学习协程的目的：不开辟线程完成多任务，为了更加节省内存资源。 原始协程程序 import time # 定义协程1 def work1(): for i in range(5): ...
Python: 进阶系列之五：并发编程：异步IO（asyncio) 协程(coroutine)与任务(task)的使用
wucong60的专栏
10-06 1880
1.协程(coroutine)的概念 根据Wikipedia, “协程是非抢先多任务的一般子例程，通过允许多个入口点用于在某些位置挂起和恢复执行的计算机程序组件”。这是一种相当技术的说法，简单来说就是函数的内部可以中断，转而去执行其他的函数，并且可以保留前一函数的状态，等在适当的时候再返回来接着执行前一函数，看起来同时像在做多件事情。人也是可以同时做多件事的，如果把协程比作一个人的话，他想去泡...
Python协程
zy010101博客
12-09 3615
Python3.5引入了关键字async来定义协程函数协程函数和普通的函数不一样，不能直接执行。必须将协程对象放入事件循环中来执行。在Python3.4的时候，引入内置模块asyncio，该模块可以将协程对象加入到事件循环中执行。
异步IO——协程与任务
菜鸟笔记
11-12 190
link: asyncio — 异步 I/O 高层级API 协程 import asyncio import time async def say_after(delay, what): await asyncio.sleep(delay) print(what) async def main(): task1 = asyncio.create_task( say_after(1, 'hello')) task2 = asyncio.crea.
协程和多任务调度
screaming的博客
05-11 3347
协程与多任务调度 时间 2016-03-31 23:02:15  IT技术博客大学习 原文  http://blogread.cn/it/article/7988?f=hot1 主题 作业调度框架 在计算机科学中，多任务(multitasking)是指在同一个时间段内运行多个任务，现代计算机作为一个复杂的系统，运行的任务往往不止一个，所以多任务调度对于计算机来说尤为
python： 协程与任务
kaluluosi111的专栏
09-22 323
协程与任务 基本概念 coroutine – 协程 协程是子例程的更一般形式。 子例程可以在某一点进入并在另一点退出。 协程则可以在许多不同的点上进入、退出和恢复。 它们可通过 async def 语句来实现。 参见 PEP 492。 coroutine function – 协程函数 返回一个 coroutine 对象的函数。协程函数可通过 async def 语句来定义，并可能包含 await、async for 和 async with 关键字。这些特性是由 PEP 492 引入的。 asyn
Python开发【异步】：asyncio
abchhcba2014的博客
11-04 309
异步asyncio asyncio是一个使用async / await语法编写并发代码的库。 asyncio用作多个Python异步框架的基础，这些框架提供高性能的网络和Web服务器，数据库连接库，分布式任务队列等。 asyncio通常非常适合IO绑定和高级结构化网络代码。 asyncio提供了一组高级API： 同时运行Python协同程序并完全控制它们的执行; ...
python协程多任务
最新发布
04-29
在 Python 中，协程是一种轻量级的线程，也称为微线程或者用户态线程。协程不是由操作系统进行调度，而是由程序员自己控制，因此更加高效。 Python 通过 asyncio 模块提供了协程的支持，它是 Python 3.4 引入的标准...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yuanzhoulvpi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值