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

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

Ce module fournit les primitives de bas niveau pour travailler avec de
multiples fils d'exécution (aussi appelés *light-weight processes* ou
*tasks*) — plusieurs fils d'exécution de contrôle partagent leur
espace de données global. Pour la synchronisation, de simples verrous
(aussi appelés des *mutexes* ou des *binary semaphores*) sont fournis.
Le module "threading" fournit une API de fils d'exécution de haut
niveau, plus facile à utiliser et construite à partir de ce module.

The module is optional.  It is supported on Windows, Linux, SGI IRIX,
Solaris 2.x, as well as on systems that have a POSIX thread (a.k.a.
"pthread") implementation.  For systems lacking the "_thread" module,
the "_dummy_thread" module is available. It duplicates this module's
interface and can be used as a drop-in replacement.

Elle définit les constantes et fonctions suivantes :

exception _thread.error

   Levée lors d'erreurs spécifiques aux fils d'exécution.

   Modifié dans la version 3.3: Ceci est à présent un synonyme de
   l'exception native "RuntimeError".

_thread.LockType

   C'est le type d'objets verrous.

_thread.start_new_thread(function, args[, kwargs])

   Démarre un nouveau fils d'exécution et renvoie son identifiant. Ce
   fil d'exécution exécute la fonction *function* avec la liste
   d'arguments *args* (qui doit être un *tuple*). L'argument optionnel
   *kwargs* spécifie un dictionnaire d'arguments de mots clés. Quand
   la fonction se termine, le fil d'exécution se termine
   silencieusement. Quand la fonction termine avec une exception non
   gérée, une trace de la pile est affichée et ensuite le fil
   d'exécution s'arrête (mais les autres fils d'exécutions continuent
   de s'exécuter).

_thread.interrupt_main()

   Raise a "KeyboardInterrupt" exception in the main thread.  A
   subthread can use this function to interrupt the main thread.

_thread.exit()

   Lève une exception "SystemExit". Quand elle n'est pas interceptée,
   le fil d'exécution se terminera silencieusement.

_thread.allocate_lock()

   Renvoie un nouveau verrou. Les méthodes des verrous sont décrites
   ci-dessous. Le verrou est initialement déverrouillé.

_thread.get_ident()

   Renvoie l'« identifiant de fil »  du fil d'exécution courant. C'est
   un entier non nul. Sa valeur n'a pas de signification directe ; il
   est destiné à être utilisé comme *cookie* magique, par exemple pour
   indexer un dictionnaire de données pour chaque fil. Les
   identifiants de fils peuvent être recyclés lorsqu'un fil
   d'exécution se termine et qu'un autre fil est créé.

_thread.stack_size([size])

   Return the thread stack size used when creating new threads.  The
   optional *size* argument specifies the stack size to be used for
   subsequently created threads, and must be 0 (use platform or
   configured default) or a positive integer value of at least 32,768
   (32 KiB). If *size* is not specified, 0 is used.  If changing the
   thread stack size is unsupported, a "RuntimeError" is raised.  If
   the specified stack size is invalid, a "ValueError" is raised and
   the stack size is unmodified.  32 KiB is currently the minimum
   supported stack size value to guarantee sufficient stack space for
   the interpreter itself.  Note that some platforms may have
   particular restrictions on values for the stack size, such as
   requiring a minimum stack size > 32 KiB or requiring allocation in
   multiples of the system memory page size - platform documentation
   should be referred to for more information (4 KiB pages are common;
   using multiples of 4096 for the stack size is the suggested
   approach in the absence of more specific information).
   Availability: Windows, systems with POSIX threads.

_thread.TIMEOUT_MAX

   La valeur maximale autorisée pour le  paramètre *timeout* de la
   méthode "Lock.acquire()". Préciser un délai d'attente supérieur à
   cette valeur lève une exception "OverflowError".

   Nouveau dans la version 3.2.

Les verrous ont les méthodes suivantes :

lock.acquire(waitflag=1, timeout=-1)

   Sans aucun argument optionnel, cette méthode acquiert le verrou
   inconditionnellement, et si nécessaire attend jusqu'à ce qu'il soit
   relâché par un autre fil d'exécution (un seul fil d'exécution à la
   fois peut acquérir le verrou — c'est leur raison d'être).

   Si l'argument *waitflag*, un entier, est présent, l'action dépend
   de sa valeur : si elle est de zéro, le verrou est seulement acquis
   s'il peut être acquis immédiatement, sans attendre, sinon le verrou
   est acquis inconditionnellement comme ci-dessus.

   Si l'argument *timeout*, en virgule flottante, est présent et
   positif, il spécifie le temps d'attente maximum en secondes avant
   de renvoyer. Un argument *timeout* négatif spécifie une attente
   illimitée. Vous ne pouvez pas spécifier un *timeout* si *waitflag*
   est à zéro.

   La valeur renvoyée est "True" si le verrou est acquis avec succès,
   sinon "False".

   Modifié dans la version 3.2: Le paramètre *timeout* est nouveau.

   Modifié dans la version 3.2: Le verrou acquis peut maintenant être
   interrompu par des signaux sur POSIX.

lock.release()

   Relâche le verrou. Le verrou doit avoir été acquis plus tôt, mais
   pas nécessairement par le même fil d'exécution.

lock.locked()

   Renvoie le statut du verrou : "True" s'il a été acquis par certains
   fils d'exécution, sinon "False".

En plus de ces méthodes, les objets verrous peuvent aussi être
utilisés via l'instruction "with", e.g. :

   import _thread

   a_lock = _thread.allocate_lock()

   with a_lock:
       print("a_lock is locked while this executes")

**Avertissements :**

* Les fils d'exécution interagissent étrangement avec les
  interruptions : l'exception "KeyboardInterrupt" sera reçue par un
  fil d'exécution arbitraire. (Quand le module "signal" est
  disponible, les interruptions vont toujours au fil d'exécution
  principal).

* Appeler la fonction "sys.exit()" ou lever l'exception "SystemExit"
  est équivalent à appeler la fonction "_thread.exit()".

* Il n'est pas possible d'interrompre la méthode "acquire()" sur un
  verrou — l'exception "KeyboardInterrupt" surviendra après que le
  verrou a été acquis.

* Quand le fil d'exécution principal s'arrête, il est défini par le
  système si les autres fils d'exécution survivent. Sur beaucoup de
  systèmes, ils sont tués sans l'exécution des clauses "try"…
  "finally" ou l'exécution des destructeurs d'objets.

* Quand le fil d'exécution principal s'arrête, il ne fait pas son
  nettoyage habituel (excepté que les clauses "try"… "finally" sont
  honorées) et les fichiers d'entrée/sortie standards ne sont pas
  nettoyés.
