迹忆客 专注技术分享

本文介绍如何创建异步函数并使用await 关键字中断进程。 我们还将学习如何在 Python 中使用任务而不是线程。

使用 await 关键字并创建一个异步函数

异步编程不是多线程； 它不是多处理而是并发编程。

我们不会讨论并发编程的整个思想和整个编码模式，但我们会讨论基本原理以及如何在 Python 中实现这些原理。

现在让我们看一个简单的例子； 我们有一个正在调用的 Func_1、Func_2 和 Func_3。

Func_1()
Func_2()
Func_3()

如果这些函数被异步调用，这意味着我们将调用 Func_1()，然后调用 Func_2()。

当 Func_1() 返回时，我们只调用 Func_2()，当 Func_2() 返回时，我们将调用 Func_3()。

如果我们使用多线程或多处理，那将与异步编程不同。 因为在多线程中，在这种情况下我们将定义三个线程，并且我们将同时运行所有这些函数。

或者，大致同时，我们将尝试同时运行它们，或者至少创造同时执行的假象。

但是，我们想做的是，比方说，Func_1() 做一些有成效的事情，然后它从数据库、API 请求一些数据，或者它只是为了等待而休眠。

如果发生这种情况，我们不想浪费 CPU 时间并开始执行 Func_2()，即使该函数尚未返回。 所以我们只能同时运行一个任务； 我们没有进行任何多处理或多线程。

但是，如果 Func_1() 正在睡眠、等待或无效率，那么我们可以利用这段时间开始执行 Func_2() 甚至 Func_3()。 要在Python中进行异步编程，我们必须导入一个名为asyncio的库。

由于我们不会将整个程序定义为异步，因此特定功能将是异步的； 我们需要使用 async 关键字来指定异步函数。

如果我们只有这个 Main_Func()，整个程序将是异步的，但我们将在下一个示例中添加其他函数。 在这个函数中，我们将使用两个 print() 函数。

并且，在这之间，我们要睡觉，但我们不会用 time.sleep(); 来睡眠。 我们将使用 asyncio.sleep()。

我们需要在调用 asyncio.sleep() 之前使用await关键字，这意味着我们将等待第二个打印语句完成。 在完成之前，我们不会做任何其他事情。

要运行 Main_Func() 函数，我们需要使用 asyncio.run() ，并且在 run() 函数内部我们将传递 Main_Func() 函数。 我们必须调用 Main_Func() 函数； 我们不仅仅将其称为多线程。

import asyncio

async def Main_Func():
    print('Before waiting')
    await asyncio.sleep(1)
    print('After waiting')

asyncio.run(Main_Func())

输出:

我们来介绍另一个异步函数Func_2()； 我们将打印两条语句并休眠两秒钟。

在 Main_Func() 函数内部，我们没有休眠，而是使用 wait 关键字调用 Func_2() 函数，但这不是异步的。

import asyncio

async def Main_Func():
    print('Before waiting')
    await Func_2()
    print('After waiting')

async def Func_2():
    print('Func_2: Before waiting')
    await asyncio.sleep(2)
    print('Func_2: After waiting')

asyncio.run(Main_Func())

由于我们正在等待函数，这与异步调用它是一样的，它不会执行这个直到所有指令都按照我们定义的那样完成。

Before waiting
Func_2: Before waiting
Func_2: After waiting
After waiting

它不是异步的； 但是，如果我们想在调用 Main_Func() 函数时执行类似的操作，则控件应打印 Main_Func() 函数的第一个打印语句。

然后，调用 Func_2() 函数，从而打印该函数的第一条打印语句。

当此函数处于休眠状态时，它应该打印 Main_Func() 函数的第二条打印语句，一旦完成，它应该打印 Func_2() 函数的第二条打印语句。

使用 create_task() 创建任务来解决问题

为此，我们需要处理任务，因此在 Main_Func() 函数的开头，我们将在调用 asyncio.create_task() 时创建一个任务，并在任务内部传递 Func_2()。

这意味着一旦我们有一些空闲时间，我们就会调用该任务。

import asyncio

async def Main_Func():
    Task=asyncio.create_task(Func_2())
    print('Before waiting')
    print('After waiting')

async def Func_2():
    print('Func_2: Before waiting')
    await asyncio.sleep(2)
    print('Func_2: After waiting')

asyncio.run(Main_Func())

运行代码后，我们可以看到从 Main_Func() 函数中打印了两条打印语句，然后就完成了。 并且执行了第一个 print 语句，但是在打印第二个 print 语句之前终止了执行。

Before waiting
After waiting
Func_2: Before waiting

这是因为 Main_Func() 是main函数，控件没有等待 Func_2() 函数，也就是说一旦控件执行到 Main_Func() 函数的末尾，控件就停止执行。

控件不需要等待 Func_2() 函数的第二个打印语句完成，以便控件将跳过它。 要修复它，我们将在 Main_Func() 函数的末尾使用 await Task。

import asyncio

async def Main_Func():
    Task=asyncio.create_task(Func_2())
    print('Before waiting')
    print('After waiting')
    await Task

async def Func_2():
    print('Func_2: Before waiting')
    await asyncio.sleep(2)
    print('Func_2: After waiting')

asyncio.run(Main_Func())

现在我们可以看到它是按照定义打印的。

Before waiting
After waiting
Func_2: Before waiting
Func_2: After waiting

如果我们想看看它是如何异步工作的，我们可以在 print 语句之间使用 sleep() 函数来实现。

这意味着我们将执行 Main_Func() 的第一个打印语句，然后控件将休眠一秒钟，这意味着 main 函数现在有空闲时间。

现在，任务有时间执行，直到 Main_Func() 完全运行。 由于 Main_Func() 函数正在休眠，这意味着我们现在有可用的 CPU 时间来通过使用任务调用 Func_2() 函数来开始执行该函数。

但是，Func_2() 函数也会进入睡眠状态，这意味着在该函数内部控件会等待两秒钟，然后控件会转到 Main_Func() 函数来打印第二条打印语句。

然后它终止，这意味着控件不再对 Func_2() 函数的其余部分感兴趣。

async def Main_Func():
    Task=asyncio.create_task(Func_2())
    print('Before waiting')
    await asyncio.sleep(1)
    print('After waiting')

输出:

Before waiting
Func_2: Before waiting
After waiting

如果我们想对此感兴趣，我们必须在 Main_Func() 函数末尾使用await Task。

它是异步的； 如您所见，顺序是 Main_Func() 函数打印第一个打印语句，然后 Func_2() 首先打印，然后 Main_Func() 打印第二个，Func_2() 打印第二个。

因为当函数进入睡眠状态时，会使用空闲时间，这样就不会浪费 CPU 时间。