为什么等待不等asyncio.create

我正在编写一个协程来在基于教程的python中执行shell命令。 这里是基本的:

import asyncio

async def async_procedure():
    process = await asyncio.create_subprocess_exec('ping', '-c', '2', 'google.com')
    await process.wait()
    print('async procedure done.')

loop = asyncio.get_event_loop()
loop.run_until_complete(async_procedure())
loop.close()

上面的代码完美地工作。 它给出了这样的结果:

PING google.com (...) 56(84) bytes of data.
64 bytes from ...: icmp_seq=1 ttl=46 time=34.8 ms
64 bytes from ...: icmp_seq=2 ttl=46 time=34.5 ms

--- google.com ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 3004ms
rtt min/avg/max/mdev = 33.771/34.437/34.881/0.407 ms
Process done!

当我尝试删除process.wait()时:

async def async_procedure():
    await asyncio.create_subprocess_exec('ping', '-c', '2', 'google.com')
    print('async procedure done.')

该脚本不能按预期工作:

Process done! # This line should be lastest line
PING google.com (...) 56(84) bytes of data.
64 bytes from ...: icmp_seq=1 ttl=46 time=21.1 ms
64 bytes from ...: icmp_seq=2 ttl=46 time=21.8 ms

--- google.com ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 21.135/21.469/21.803/0.334 ms

但是在一个非常相似的例子中没有问题:

async def async_procedure():
    await asyncio.sleep(2)
    print('async procedure done')
  • 那么为什么不等待asyncio.create_subprocess_exec()?
  • 文档(https://docs.python.org/3/library/asyncio-task.html#coroutine)说:

    结果=等待未来或结果=未来产出 - 暂停协程,直到未来完成,然后返回未来的结果,或引发将被传播的异常。 (如果将来被取消,它将引发一个CancelledError异常。)请注意,任务是期货,所有关于期货的说法也适用于任务。

    结果=等待协程或结果=协程的结果 - 等待另一个协程生成一个结果(或引发一个将被传播的异常)。 协程表达式必须是对另一个协程的调用。

    返回表达式 - 使用await或yield从等待此协议的协程生成结果。

    引发异常 - 在使用await或yield从等待这个协程的协程中产生异常。

  • 协程暂停等待时,实际上过程的流程是什么?
  • 这里是asyncio.create_subprocess_exec()和asyncio.sleep()的源代码是协同程序。 他们都是协程:

    @coroutine
    def create_subprocess_exec(program, *args, stdin=None, stdout=None,
                               stderr=None, loop=None,
                               limit=streams._DEFAULT_LIMIT, **kwds):
        if loop is None:
            loop = events.get_event_loop()
        protocol_factory = lambda: SubprocessStreamProtocol(limit=limit,
                                                            loop=loop)
        transport, protocol = yield from loop.subprocess_exec(
                                                protocol_factory,
                                                program, *args,
                                                stdin=stdin, stdout=stdout,
                                                stderr=stderr, **kwds)
        return Process(transport, protocol, loop)
    
    
    @coroutine
    def sleep(delay, result=None, *, loop=None):
        """Coroutine that completes after a given time (in seconds)."""
        if delay == 0:
            yield
            return result
    
        if loop is None:
            loop = events.get_event_loop()
        future = loop.create_future()
        h = future._loop.call_later(delay,
                                    futures._set_result_unless_cancelled,
                                    future, result)
        try:
            return (yield from future)
        finally:
            h.cancel()
    

    你等待这个过程开始。 你没有等待它完成。 await process.wait()等待它完成。

    链接地址: http://www.djcxy.com/p/53247.html

    上一篇: Why await doesn't wait asyncio.create

    下一篇: Seemingly infinite recursion with generator based coroutines