如何同步运行 Python 协程，直到第一次等待，就像在 C# 中一样？

Question

我正在使用一些 asyncio Python 代码，但遇到了协程排序问题。我对 C# 有一定的经验，所以我会用它作为例子。

在 C# 中我可以编写：

using System;
using System.Threading.Tasks;

public class Program
{
    async static Task<int> foo(int n, int delay)
    {
        Console.WriteLine("Foo start {0}",n);
        await Task.Delay(delay);
        Console.WriteLine("Foo end {0}",n);
        return 0;
    }

    public static void Main()
    {
        Task<int> t1 = foo(1,300);
        Task<int> t2 = foo(2,200);
        
        Task.WaitAll(new []{t2,t1});// Reverse on purpose
    }
}

结果如下，注意协程的开始匹配调用顺序，不是等待顺序。这是由于协程函数如何划分到生成器中而得到保证的。 IE。它们总是同步运行，直到第一个 await。

Foo start 1
Foo start 2
Foo end 2
Foo end 1

但是当我在 Python 中做同样的事情时，我会得到不同的顺序。

import asyncio
async def foo(n,delay):
    print(f"Foo start {n}")
    await asyncio.sleep(delay/1000)
    print(f"Foo end {n}")
    return 0


async def main():
    t1 = foo(1,300)
    t2 = foo(2,200)
    
    await asyncio.gather(t2,t1) # Reverse on purpose
    
asyncio.run(main())

Foo start 2
Foo start 1
Foo end 2
Foo end 1

我也知道这是为什么 - 因为 foo(1,300) 返回一个生成器，它在协程等待/调度之前不会启动。

我的问题是如何在 Python 中实现类似 C# 的行为，这意味着协程在调用它们时开始而不会中断，直到第一个 await？

我试过了

t1 = asyncio.create_task(foo(1,300))
t2 = asyncio.create_task(foo(2,200))

哪个解决了问题，但调度顺序真的有保证吗？

Answer 1

你试过这个吗：

t1 = asyncio.create_task(foo(1,300))
await asyncio.sleep(0.0)
t2 = asyncio.create_task(foo(2,200))
await asyncio.sleep(0.0)

这应该总是有效的，因为它会在每个任务创建后产生事件循环。在创建下一个任务之前，每个任务都应该开始并运行到第一个等待。我说“应该”是因为我自己实际上并没有在实践中这样做过。但我强烈希望它适用于所有情况。

如果你有很多任务，你可以用这样的小函数清理代码：

async def start_sequential(*coros):
    for c in coros:
        asyncio.create_task(c)
        await asyncio.sleep(0.0)

c1 = foo(1, 300)
c2 = foo(2, 200)
await start_sequential(c1, c2)

Answer 2

asyncio.create_task()，顾名思义，创建一个task.Task 实例。该任务是在task.Task 的构造函数中安排的

self._loop.call_soon(self.__step, context=self._context)

来自BaseEventLoop.call_soon的文档字符串：

安排尽快调用回调。 这作为 FIFO 队列运行：回调在 他们注册的顺序。每个回调将是 只调用一次。

只要您使用不覆盖此行为的事件循环，我会说您可以按照您的意图使用create_task。据我所知，asyncio 中的所有事件循环都没有。