17. Exécution concourante
*************************

Les modules documentés dans ce chapitre fournissent des outils
d'exécution concourante de code. Le choix de l'outil approprié dépend
de la tâche à exécuter (limitée par le CPU (*CPU bound*), ou limitée
la vitesse des entrées-sorties (*IO bound*)) et du style de
développement désiré (coopération gérée par des évènements ou
multitâche préemptif). En voici un survol :

* 17.1. "threading" — Parallélisme basé sur les fils d’exécution
  (*threads*)

  * 17.1.1. Données locales au fil d'exécution

  * 17.1.2. Objets *Threads*

  * 17.1.3. Verrous

  * 17.1.4. RLock Objects

  * 17.1.5. Condition Objects

  * 17.1.6. Semaphore Objects

    * 17.1.6.1. "Semaphore" Example

  * 17.1.7. Event Objects

  * 17.1.8. Timer Objects

  * 17.1.9. Barrier Objects

  * 17.1.10. Using locks, conditions, and semaphores in the "with"
    statement

* 17.2. "multiprocessing" — Parallélisme par processus

  * 17.2.1. Introduction

    * 17.2.1.1. La classe "Process"

    * 17.2.1.2. Contextes et méthodes de démarrage

    * 17.2.1.3. Échange d'objets entre les processus

    * 17.2.1.4. Synchronisation entre processus

    * 17.2.1.5. Partager un état entre les processus

    * 17.2.1.6. Utiliser un réservoir de *workers*

  * 17.2.2. Référence

    * 17.2.2.1. "Process" et exceptions

    * 17.2.2.2. Tubes (*pipes*) et Queues

    * 17.2.2.3. Divers

    * 17.2.2.4. Objets de connexions

    * 17.2.2.5. Primitives de synchronisation

    * 17.2.2.6. Objets "ctypes" partagés

      * 17.2.2.6.1. Le module "multiprocessing.sharedctypes"

    * 17.2.2.7. Gestionnaires

      * 17.2.2.7.1. Gestionnaires personnalisés

      * 17.2.2.7.2. Utiliser un gestionnaire distant

    * 17.2.2.8. Objets mandataires

      * 17.2.2.8.1. Nettoyage

    * 17.2.2.9. Bassins de processus

    * 17.2.2.10. Auditeurs et Clients

      * 17.2.2.10.1. Formats d'adresses

    * 17.2.2.11. Clés d'authentification

    * 17.2.2.12. Journalisation

    * 17.2.2.13. Le module "multiprocessing.dummy"

  * 17.2.3. Lignes directrices de programmation

    * 17.2.3.1. Toutes les méthodes de démarrage

    * 17.2.3.2. Les méthodes de démarrage *spawn* et *forkserver*

  * 17.2.4. Exemples

* 17.3. Le paquet "concurrent"

* 17.4. "concurrent.futures" --- Launching parallel tasks

  * 17.4.1. Executor Objects

  * 17.4.2. ThreadPoolExecutor

    * 17.4.2.1. ThreadPoolExecutor Example

  * 17.4.3. ProcessPoolExecutor

    * 17.4.3.1. ProcessPoolExecutor Example

  * 17.4.4. Future Objects

  * 17.4.5. Module Functions

  * 17.4.6. Exception classes

* 17.5. "subprocess" — Gestion de sous-processus

  * 17.5.1. Utiliser le module "subprocess"

    * 17.5.1.1. Arguments fréquemment utilisés

    * 17.5.1.2. Constructeur de *Popen*

    * 17.5.1.3. Exceptions

  * 17.5.2. Considérations de sécurité

  * 17.5.3. Objets *Popen*

  * 17.5.4. Utilitaires *Popen* pour Windows

    * 17.5.4.1. Constantes

  * 17.5.5. Ancienne interface (*API*) haut-niveau

  * 17.5.6. Remplacer les fonctions plus anciennes par le module
    "subprocess"

    * 17.5.6.1. Remplacement des *backquotes* des *shells /bin/sh*

    * 17.5.6.2. Remplacer les *pipes* du *shell*

    * 17.5.6.3. Remplacer "os.system()"

    * 17.5.6.4. Remplacer les fonctions de la famille "os.spawn"

    * 17.5.6.5. Remplacer "os.popen()", "os.popen2()", "os.popen3()"

    * 17.5.6.6. Remplacer les fonctions du module "popen2"

  * 17.5.7. Remplacement des fonctions originales d'invocation du
    *shell*

  * 17.5.8. Notes

    * 17.5.8.1. Convertir une séquence d'arguments vers une chaîne de
      caractères sous Windows

* 17.6. "sched" --- Event scheduler

  * 17.6.1. Scheduler Objects

* 17.7. "queue" — File synchronisée

  * 17.7.1. Objets "Queue"

Les modules suivants servent de fondation pour certains services cités
ci-dessus.

* 17.8. "dummy_threading" --- Module de substitution au module
  "threading"

* 17.9. "_thread" — API bas niveau de gestion de fils d'exécution

* 17.10. "_dummy_thread" --- Module de substitution pour le module
  "_thread"
