Ce document est relatif à une vieille version de Python qui n'est plus soutenue. Mettez à jour votre version et lisez Bienvenue sur la documentation de la version stable actuelle de Python.

# `_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.

Modifié dans la version 3.7: Ce module était optionnel, il est maintenant toujours disponible.

Ce module définit les constantes et les 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`()

  Simule l'effet d'un signal `signal.SIGINT` arrivant au fil d'exécution principal. Un fil d'exécution peut utiliser cette fonction pour interrompre le fil d'exécution principal.

  Si le signal `signal.SIGINT` n'est pas géré par Python (s'il a été paramétré à `signal.SIG_DFL` ou `signal.SIG_IGN`), cette fonction ne fait rien.

`_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])

  Renvoie la taille de la pile d'exécution utilisée lors de la création de nouveaux fils d'exécution. L'argument optionnel size spécifie la taille de pile à utiliser pour les fils créés ultérieurement, et doit être à 0 (pour utiliser la taille de la plate-forme ou la valeur configurée par défaut) ou un entier positif supérieur ou égal à 32 768 (32 Kio). Si size n'est pas spécifié, 0 est utilisé. Si la modification de la taille de la pile de fils n'est pas prise en charge, une exception `RuntimeError` est levée. Si la taille de la pile spécifiée n'est pas valide, une exception `ValueError` est levée et la taille de la pile n'est pas modifiée. 32 Kio est actuellement la valeur minimale de taille de la pile prise en charge pour garantir un espace de pile suffisant pour l'interpréteur lui-même. Notez que certaines plates-formes peuvent avoir des restrictions particulières sur les valeurs de taille de la pile, telles que l'exigence d'une taille de pile minimale > 32 Kio ou d'une allocation en multiples de la taille de page de la mémoire du système – la documentation de la plate-forme devrait être consultée pour plus d'informations (4 Kio sont courants ; en l'absence de renseignements plus spécifiques, l'approche suggérée est l'utilisation de multiples de 4 096 octets pour la taille de la pile).

  Disponibilité : Windows et systèmes gérant les fils d'exécution POSIX.

`_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.