Do Python asyncio Streams maintain order over multiple writers and readers?

Question

Systems such as beanstalk client-server communications or HTTP pipelining preserve the ordering between multiple requests and responses over a shared connection.

In other words, the first request received by server is the first one the client receives a response back for.

When using Python Streams to access this kind of systems as a client, does Python likewise maintain ordering among writers and readers? In such a scenario, we'd have:

opened a connection, getting a StreamWriter and a StreamReader instance
shared those within the asyncio application (within the same asyncio event loop thread)
different parts of the asyncio application writing to and reading (awaiting) from them

The code accessing the stream would be in a single place such as in the example below, but could be used from different parts of the app repeatedly before any response is received back.

async def request(host, port, data):
    reader, writer = await asyncio.open_connection(host, port)
    writer.write(data)
    response = await reader()
    ...

So when our application has called request() & written to the stream, data is transmitted, remote server is working and finally returning response.

But until then, we await for response, and other code runs, calling our request() function to send more requests and await for responses in turn.

So, to put the question in a more practical terms here, are the many reader awaiters always getting access to the responses in the same order they sent requests, or not?

Somewhat similar question that however does not provide answer for this one: Does Python's asyncio lock.acquire maintain order?

Do Python asyncio Streams maintain order over multiple writers and readers?

Answers (1)

Related Questions