How to use Python asynchronous non-blocking streams

1. Asynchronous streams

One of the main benefits of asyncio is the ability to use non-blocking streams.

Asyncio provides non-blocking I/O socket programming. This is provided via streaming.

Can open sockets that provide access to stream writers and stream writers. Use coroutines to write and read data from the stream and pause when appropriate. Once completed, the socket can be closed.

The asynchronous streaming functionality is low-level, which means that any protocols required must be implemented manually.

This may include common web protocols such as:

• HTTP or HTTPS for interacting with the web server

• SMTP for interacting with email servers

• FTP for interacting with file servers.

These streams can also be used to create servers to handle requests using standard protocols, or to develop your own application-specific protocols.

Now that we know what asynchronous streams are, let’s see how to use them.

2. How to open the connection

You can use the asyncio.open_connection() function to open the asyncio TCP client socket connection.

This is a coroutine that must wait and return once the socket connection is opened.

This function returns the StreamReader and StreamWriter objects used to interact with the socket.

...
# open a connection
reader, writer = await asyncio.open_connection(...)

There are multiple parameters that can be used to configure the socket connection in the asyncio.open_connection() function.. The two required parameters are host and port.

host is a string specifying the server to connect to, such as a domain name or IP address.

port is the socket port number, such as 80 for HTTP server, 443 for HTTPS server, 23 for SMTP, etc.

...
# open a connection to an http server
reader, writer = await asyncio.open_connection('www.google.com', 80)

Supports encrypted socket connections via SSL protocol. Perhaps the most common example is HTTPS, which is replacing HTTP. This can be achieved by setting the "ssl" parameter to True.

...
# open a connection to an https server
reader, writer = await asyncio.open_connection('www.google.com', 443, ssl=True)

3. How to start the server

You can use the asyncio.start_server() function to open the asyncio TCP server socket. This is a coroutine that must wait.

This function returns an asyncio.Server object representing the running server.

...
# start a tcp server
server = await asyncio.start_server(...)

The three required parameters are the callback function, host and port. When the client connects to the server, the callback function is called, which is a named custom function.

The host is the domain name or IP address that the client will specify to connect to. The port used by FTP is 21 and the port used by HTTP is 80. These ports are the socket port numbers used to receive connections.

# handle connections
async def handler(reader, writer):
    # ...
...
# start a server to receive http connections
server = await asyncio.start_server(handler, '127.0.0.1', 80)

4. How to use StreamWriter to write data

You can use asyncio.StreamWriter to transfer data to the socket. Data is written in bytes. Byte data can be written to a socket using the write() method.

...
# write byte data
writer.write(byte_data)

Alternatively, the writelines() method can be used to write multiple "lines" of byte data organized into a list or iterable.

...
# write lines of byte data
writer.writelines(byte_lines)

There are no methods to write data blocks or suspend calling coroutines. After writing byte data, it is best to empty the socket via the drain() method. This is a coroutine that will cause the caller to pause until the data is transferred and the socket is ready.

...
# write byte data
writer.write(byte_data)
# wait for data to be transmitted
await writer.drain()

5. How to use StreamReader to read data

Use asyncio.StreamReader to read data in the socket. The data is read in bytes format, so strings may need to be encoded before use. All read methods are coroutines that must wait.

You can read any number of bytes through the read() method, which will read until the end of file (EOF).

...
# read byte data
byte_data = await reader.read()

Additionally, the number of bytes to read can be specified via the "n" parameter. It might help if you know the expected number of bytes for the next response.

...
# read byte data
byte_data = await reader.read(n=100)

You can use the readline() method to read a single line of data. This will return bytes until a newline character "\n" or EOF is encountered.

This is useful when reading standard protocols that operate with lines of text.

...
# read a line data
byte_line = await reader.readline()

Additionally, there is a readexactly() method to read the exact number of bytes, otherwise an exception will be thrown, and a readuntil() method that will read bytes until the bytes are read Specify characters.

6. How to close the connection

You can use the asyncio.StreamWriter object to close the network socket. The socket can be closed by calling the close() method. This method does not block.

...
# close the socket
writer.close()

Although the close() method is non-blocking, we can wait for the socket to be completely closed before continuing. This can be achieved through the wait_closed() method. This is a coroutine that can be awaited.

...
# close the socket
writer.close()
# wait for the socket to close
await writer.wait_closed()

We can check whether the socket has been closed or is being closed through the is_closing() method.

...
# check if the socket is closed or closing
if writer.is_closing():
    # ...

The above is the detailed content of How to use Python asynchronous non-blocking streams. For more information, please follow other related articles on the PHP Chinese website!