Comment utiliser les flux asynchrones non bloquants Python

1. Flux asynchrones

L'un des principaux avantages d'asyncio est la possibilité d'utiliser des flux non bloquants.

Asyncio fournit une programmation de socket E/S non bloquante. Ceci est fourni via le streaming.

Peut ouvrir des sockets qui donnent accès aux rédacteurs de flux et aux rédacteurs de flux. Utilisez des coroutines pour écrire et lire les données du flux et faites une pause le cas échéant. Une fois terminé, le socket peut être fermé.

La fonctionnalité de streaming asynchrone est de bas niveau, ce qui signifie que tous les protocoles requis doivent être implémentés manuellement.

Cela peut inclure des protocoles Web courants tels que :

• HTTP ou HTTPS pour interagir avec les serveurs Web

• SMTP pour interagir avec les serveurs de messagerie

• pour interagir avec les serveurs de fichiers FTP.

Ces flux peuvent également être utilisés pour créer des serveurs pour traiter les requêtes utilisant des protocoles standards, ou pour développer vos propres protocoles spécifiques à une application.

Maintenant que nous savons ce que sont les flux asynchrones, voyons comment les utiliser.

2. Comment ouvrir la connexion

Vous pouvez utiliser la fonction asyncio.open_connection() pour ouvrir la connexion socket client TCP asyncio.

Il s'agit d'une coroutine qui doit attendre et revenir une fois la connexion socket ouverte.

Cette fonction renvoie les objets StreamReader et StreamWriter pour interagir avec le socket.

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

Il existe plusieurs paramètres qui peuvent être utilisés pour configurer la connexion socket dans la fonction asyncio.open_connection(). Les deux paramètres requis sont l'hôte et le port.

host est une chaîne spécifiant le serveur auquel se connecter, comme un nom de domaine ou une adresse IP.

port est le numéro de port du socket, tel que 80 pour le serveur HTTP, 443 pour le serveur HTTPS, 23 pour SMTP, etc.

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

Prend en charge les connexions socket cryptées via le protocole SSL. L’exemple le plus courant est peut-être HTTPS, qui remplace HTTP. Ceci peut être réalisé en définissant le paramètre "ssl" sur True.

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

3. Comment démarrer le serveur

Vous pouvez utiliser la fonction asyncio.start_server() pour ouvrir le socket du serveur TCP asyncio. C'est une coroutine qui doit attendre.

Cette fonction renvoie un objet asyncio.Server représentant le serveur en cours d'exécution.

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

Les trois paramètres requis sont la fonction de rappel, l'hôte et le port. Lorsque le client se connecte au serveur, la fonction de rappel est appelée, qui est une fonction personnalisée nommée.

Host est le nom de domaine ou l'adresse IP auquel le client spécifiera pour se connecter. Le port utilisé par FTP est le 21 et celui utilisé par HTTP est le 80. Ces ports sont les numéros de port de socket utilisés pour recevoir les connexions.

# 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. Comment utiliser StreamWriter pour écrire des données

Vous pouvez utiliser asyncio.StreamWriter pour transférer des données vers le socket. Les données sont écrites en octets. Les données d'octets peuvent être écrites sur un socket à l'aide de la méthode write().

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

Alternativement, vous pouvez utiliser la méthode writelines() pour écrire plusieurs "lignes" de données d'octets organisées en liste ou itérables.

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

Il n'y a aucun moyen d'écrire un bloc de données ou de suspendre la coroutine appelante. Après avoir écrit les données d'octet, il est préférable de vider le socket via la méthode drain(). Il s'agit d'une coroutine qui amènera l'appelant à faire une pause jusqu'à ce que les données soient transférées et que le socket soit prêt.

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

5. Comment utiliser StreamReader pour lire des données

Utilisez asyncio.StreamReader pour lire les données dans le socket. Les données sont lues au format octets, les chaînes devront donc peut-être être codées avant utilisation. Toutes les méthodes de lecture sont des coroutines qui doivent attendre.

Vous pouvez lire n'importe quel nombre d'octets via la méthode read(), qui lira jusqu'à la fin du fichier (EOF).

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

De plus, le nombre d'octets à lire peut être spécifié via le paramètre "n". Cela peut être utile si vous connaissez le nombre d'octets attendu pour la prochaine réponse.

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

Vous pouvez utiliser la méthode readline() pour lire une seule ligne de données. Cela renverra des octets jusqu'à ce qu'une nouvelle ligne 'n' ou EOF soit rencontrée.

Ceci est utile lors de la lecture de protocoles standard qui utilisent des opérations sur les lignes de texte.

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

De plus, il existe une méthode readexactly() pour lire le nombre exact d'octets, sinon une exception sera levée, et une méthode readuntil() qui lira les octets jusqu'à ce que le caractère spécifié sous forme d'octets soit lu.

6. Comment fermer la connexion

Vous pouvez utiliser l'objet asyncio.StreamWriter pour fermer la prise réseau. Le socket peut être fermé en appelant la méthode close(). Cette méthode ne bloque pas.

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

Bien que la méthode close() soit non bloquante, on peut attendre que le socket soit complètement fermé avant de continuer. Ceci peut être réalisé grâce à la méthode wait_closed(). C'est une coroutine que l'on peut attendre.

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

Nous pouvons vérifier si le socket a été fermé ou est en cours de fermeture via la méthode is_closing().

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!