18.5. "asyncio" — Entrées/Sorties asynchrone, boucle d’évènements, coroutines et tâches
***************************************************************************************

Nouveau dans la version 3.4.

**Code source :** Lib/asyncio/

======================================================================

Ce module fournit l’infrastructure pour écrire des programmes à fil
d’exécution unique (*single-thread en anglais*) mais permettant
l’exécution de code concurrent en utilisant les coroutines, les accès
multiplexés aux entrées-sorties par l’intermédiaire de *sockets* ou
autres ressources, la gestion de clients et serveurs réseaux et
d’autres fonctions primitives associées. Voici une liste plus
détaillée du contenu du paquet :

* une boucle d’évènements prête à l’emploi dont les implémentations
  sont spécifiques à leur plateforme ;

* Des abstractions pour les couches transport et protocole (similaire
  à celles proposées par Twisted) ;

* pour la gestion effective de TCP, UDP, SSL, la communication inter-
  processus par tubes, les appels différés, et autres (certains
  peuvent être dépendant du système) ;

* une classe "Future" qui imite celle du "concurrent.futures" module,
  mais qui est adaptée pour fonctionner avec la boucle d’évènements ;

* des coroutines et tâches qui se basent sur "yield from" (**PEP
  380**), pour écrire du code concurrent de manière séquentielle ;

* annulation de la gestion de la classe "Future"s et coroutines ;

* des primitives de synchronisation à utiliser entre des coroutines
  dans un fil d’exécution unique, en imitant celles présentes dans le
  module "threading" ;

* une interface pour déléguer des tâches à un groupe de fils
  d’exécutions, lorsque vous avez absolument besoin d’utiliser une
  bibliothèque qui effectue des entrées-sorties bloquantes.

Programmer de façon asynchrone est plus complexe que programmer d’une
façon séquentielle : lisez la page Develop with asyncio qui liste les
pièges fréquents et explique la manière de les éviter. Activer le mode
de débogage d’asyncio pendant le développement afin de détecter les
problèmes courants.

Table des matières :

* 18.5.1. Base Event Loop

  * 18.5.1.1. Exécuter une boucle d'évènements

  * 18.5.1.2. Appels

  * 18.5.1.3. Appels différés

  * 18.5.1.4. Futurs

  * 18.5.1.5. Tâches

  * 18.5.1.6. Créer des connections

  * 18.5.1.7. Attendre des connections

  * 18.5.1.8. Surveiller des descripteurs de fichiers

  * 18.5.1.9. Opérations bas niveau sur les *socket*

  * 18.5.1.10. Résout le nom d'hôte

  * 18.5.1.11. Connect pipes

  * 18.5.1.12. Signaux UNIX

  * 18.5.1.13. Exécuteur

  * 18.5.1.14. API de gestion d'erreur

  * 18.5.1.15. Mode débogage

  * 18.5.1.16. Serveur

  * 18.5.1.17. Handle

  * 18.5.1.18. Exemples de boucles d'évènements

    * 18.5.1.18.1. "Hello World" avec "call_soon()"

    * 18.5.1.18.2. Afficher la date actuelle avec "call_later()"

    * 18.5.1.18.3. Watch a file descriptor for read events

    * 18.5.1.18.4. Définit les gestionnaires de signaux pour *SIGINT*
      et *SIGTERM*

* 18.5.2. Boucles d'évènements

  * 18.5.2.1. Fonctions des boucles d'évènements

  * 18.5.2.2. Boucles d'évènements disponibles

  * 18.5.2.3. Support des plateformes

    * 18.5.2.3.1. Windows

    * 18.5.2.3.2. Mac OS X

  * 18.5.2.4. Event loop policies and the default policy

  * 18.5.2.5. Event loop policy interface

  * 18.5.2.6. Access to the global loop policy

  * 18.5.2.7. Customizing the event loop policy

* 18.5.3. Tâches et coroutines

  * 18.5.3.1. Coroutines

    * 18.5.3.1.1. Exemple : Coroutine "Hello World"

    * 18.5.3.1.2. Exemple : Coroutine affichant la date actuelle

    * 18.5.3.1.3. Exemple : Chaîner des coroutines

  * 18.5.3.2. InvalidStateError

  * 18.5.3.3. TimeoutError

  * 18.5.3.4. Future

    * 18.5.3.4.1. Exemple : Futur avec "run_until_complete()"

    * 18.5.3.4.2. Exemple : Futur avec "run_forever()"

  * 18.5.3.5. Task

    * 18.5.3.5.1. Exemple : Exécution parallèle de tâches

  * 18.5.3.6. Task functions

* 18.5.4. Transports et protocoles (APi basée sur des fonctions de
  rappel)

  * 18.5.4.1. Transports

    * 18.5.4.1.1. BaseTransport

    * 18.5.4.1.2. ReadTransport

    * 18.5.4.1.3. WriteTransport

    * 18.5.4.1.4. DatagramTransport

    * 18.5.4.1.5. BaseSubprocessTransport

  * 18.5.4.2. Protocols

    * 18.5.4.2.1. Protocol classes

    * 18.5.4.2.2. Connection callbacks

    * 18.5.4.2.3. Streaming protocols

    * 18.5.4.2.4. Protocoles de datagrammes

    * 18.5.4.2.5. Flow control callbacks

    * 18.5.4.2.6. Coroutines et protocoles

  * 18.5.4.3. Exemples de protocole

    * 18.5.4.3.1. Protocole "*echo client*" en TCP

    * 18.5.4.3.2. Protocole "*echo serveur*" en TCP

    * 18.5.4.3.3. Protocole "*echo client*" en UDP

    * 18.5.4.3.4. Protocole "*echo serveur*" en UDP

    * 18.5.4.3.5. Register an open socket to wait for data using a
      protocol

* 18.5.5. Streams (coroutine based API)

  * 18.5.5.1. Stream functions

  * 18.5.5.2. StreamReader

  * 18.5.5.3. StreamWriter

  * 18.5.5.4. StreamReaderProtocol

  * 18.5.5.5. IncompleteReadError

  * 18.5.5.6. LimitOverrunError

  * 18.5.5.7. Stream examples

    * 18.5.5.7.1. TCP echo client using streams

    * 18.5.5.7.2. TCP echo server using streams

    * 18.5.5.7.3. Récupère les en-têtes HTTP

    * 18.5.5.7.4. Register an open socket to wait for data using
      streams

* 18.5.6. Subprocess

  * 18.5.6.1. Boucle d'évènements Windows

  * 18.5.6.2. Créer un processus fils : API de haut niveau utilisant
    "Process"

  * 18.5.6.3. Create a subprocess: low-level API using
    subprocess.Popen

  * 18.5.6.4. Constantes

  * 18.5.6.5. Process

  * 18.5.6.6. Processus fils et fils d'exécution

  * 18.5.6.7. Subprocess examples

    * 18.5.6.7.1. Subprocess using transport and protocol

    * 18.5.6.7.2. Subprocess using streams

* 18.5.7. Primitives de synchronisation

  * 18.5.7.1. Locks

    * 18.5.7.1.1. Lock

    * 18.5.7.1.2. Event

    * 18.5.7.1.3. Condition

  * 18.5.7.2. Sémaphores

    * 18.5.7.2.1. Sémaphore

    * 18.5.7.2.2. BoundedSemaphore

* 18.5.8. Queues

  * 18.5.8.1. Queue

  * 18.5.8.2. PriorityQueue

  * 18.5.8.3. LifoQueue

    * 18.5.8.3.1. Exceptions

* 18.5.9. Programmer avec *asyncio*

  * 18.5.9.1. Mode de débogage d'*asyncio*

  * 18.5.9.2. Annulation

  * 18.5.9.3. Concourance et *multithreading*

  * 18.5.9.4. Gérer les fonctions bloquantes correctement

  * 18.5.9.5. Journalisation

  * 18.5.9.6. Détecte les coroutines qui ne sont jamais exécutées

  * 18.5.9.7. Detect exceptions never consumed

  * 18.5.9.8. Chaîner les coroutines correctement

  * 18.5.9.9. Pending task destroyed

  * 18.5.9.10. Close transports and event loops

Voir aussi:

  Le module "asyncio" a été présenté dans la **PEP 3156**. La **PEP
  3153** décrit les motivations premières concernant les couches
  transports et protocoles.
