1092 lines
41 KiB
Plaintext
1092 lines
41 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
||
# Copyright (C) 1990-2016, Python Software Foundation
|
||
# This file is distributed under the same license as the Python package.
|
||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
#
|
||
#, fuzzy
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 2.7\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
|
||
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
|
||
#: ../Doc/library/threading.rst:2
|
||
msgid ":mod:`threading` --- Higher-level threading interface"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:7
|
||
msgid "**Source code:** :source:`Lib/threading.py`"
|
||
msgstr "**Code source:** :source:`Lib/threading.py`"
|
||
|
||
#: ../Doc/library/threading.rst:11
|
||
msgid ""
|
||
"This module constructs higher-level threading interfaces on top of the "
|
||
"lower level :mod:`thread` module. See also the :mod:`mutex` and :mod:`Queue` "
|
||
"modules."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:15
|
||
msgid ""
|
||
"The :mod:`dummy_threading` module is provided for situations where :mod:"
|
||
"`threading` cannot be used because :mod:`thread` is missing."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:20
|
||
msgid ""
|
||
"Starting with Python 2.6, this module provides :pep:`8` compliant aliases "
|
||
"and properties to replace the ``camelCase`` names that were inspired by "
|
||
"Java's threading API. This updated API is compatible with that of the :mod:"
|
||
"`multiprocessing` module. However, no schedule has been set for the "
|
||
"deprecation of the ``camelCase`` names and they remain fully supported in "
|
||
"both Python 2.x and 3.x."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:29
|
||
msgid ""
|
||
"Starting with Python 2.5, several Thread methods raise :exc:`RuntimeError` "
|
||
"instead of :exc:`AssertionError` if called erroneously."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:34
|
||
msgid ""
|
||
"In CPython, due to the :term:`Global Interpreter Lock`, only one thread can "
|
||
"execute Python code at once (even though certain performance-oriented "
|
||
"libraries might overcome this limitation). If you want your application to "
|
||
"make better use of the computational resources of multi-core machines, you "
|
||
"are advised to use :mod:`multiprocessing`. However, threading is still an "
|
||
"appropriate model if you want to run multiple I/O-bound tasks simultaneously."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:43
|
||
msgid "This module defines the following functions and objects:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:48
|
||
msgid ""
|
||
"Return the number of :class:`Thread` objects currently alive. The returned "
|
||
"count is equal to the length of the list returned by :func:`.enumerate`."
|
||
msgstr ""
|
||
"Renvoie le nombre d'objets :class:`Thread` actuellement vivants. Le compte "
|
||
"renvoyé est égal à la longueur de la liste renvoyée par :func:`.enumerate`."
|
||
|
||
#: ../Doc/library/threading.rst:51
|
||
msgid "Added ``active_count()`` spelling."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:58
|
||
msgid ""
|
||
"A factory function that returns a new condition variable object. A condition "
|
||
"variable allows one or more threads to wait until they are notified by "
|
||
"another thread."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:62
|
||
msgid "See :ref:`condition-objects`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:68
|
||
msgid ""
|
||
"Return the current :class:`Thread` object, corresponding to the caller's "
|
||
"thread of control. If the caller's thread of control was not created "
|
||
"through the :mod:`threading` module, a dummy thread object with limited "
|
||
"functionality is returned."
|
||
msgstr ""
|
||
"Renvoie l'objet :class:`Thread` courant, correspondant au fil de contrôle de "
|
||
"l'appelant. Si le fil de contrôle de l'appelant n'a pas été créé via le "
|
||
"module :mod:`Thread`, un objet *thread* factice aux fonctionnalités limitées "
|
||
"est renvoyé."
|
||
|
||
#: ../Doc/library/threading.rst:73
|
||
msgid "Added ``current_thread()`` spelling."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:79
|
||
msgid ""
|
||
"Return a list of all :class:`Thread` objects currently alive. The list "
|
||
"includes daemonic threads, dummy thread objects created by :func:"
|
||
"`current_thread`, and the main thread. It excludes terminated threads and "
|
||
"threads that have not yet been started."
|
||
msgstr ""
|
||
"Renvoie une liste de tous les objets fil d'exécution :class:`Thread` "
|
||
"actuellement vivants. La liste inclut les fils démons, les fils factices "
|
||
"créés par :func:`current_thread` et le fil principal. Elle exclut les fils "
|
||
"terminés et les fils qui n'ont pas encore été lancés."
|
||
|
||
#: ../Doc/library/threading.rst:88
|
||
msgid ""
|
||
"A factory function that returns a new event object. An event manages a flag "
|
||
"that can be set to true with the :meth:`~Event.set` method and reset to "
|
||
"false with the :meth:`clear` method. The :meth:`wait` method blocks until "
|
||
"the flag is true."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:93
|
||
msgid "See :ref:`event-objects`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:98
|
||
msgid ""
|
||
"A class that represents thread-local data. Thread-local data are data whose "
|
||
"values are thread specific. To manage thread-local data, just create an "
|
||
"instance of :class:`local` (or a subclass) and store attributes on it::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:105
|
||
msgid "The instance's values will be different for separate threads."
|
||
msgstr ""
|
||
"Les valeurs dans l'instance sont différentes pour des *threads* différents."
|
||
|
||
#: ../Doc/library/threading.rst:107
|
||
msgid ""
|
||
"For more details and extensive examples, see the documentation string of "
|
||
"the :mod:`_threading_local` module."
|
||
msgstr ""
|
||
"Pour plus de détails et de nombreux exemples, voir la chaîne de "
|
||
"documentation du module :mod:`_threading_local`."
|
||
|
||
#: ../Doc/library/threading.rst:115
|
||
msgid ""
|
||
"A factory function that returns a new primitive lock object. Once a thread "
|
||
"has acquired it, subsequent attempts to acquire it block, until it is "
|
||
"released; any thread may release it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:119
|
||
msgid "See :ref:`lock-objects`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:124
|
||
msgid ""
|
||
"A factory function that returns a new reentrant lock object. A reentrant "
|
||
"lock must be released by the thread that acquired it. Once a thread has "
|
||
"acquired a reentrant lock, the same thread may acquire it again without "
|
||
"blocking; the thread must release it once for each time it has acquired it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:129
|
||
msgid "See :ref:`rlock-objects`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:135
|
||
msgid ""
|
||
"A factory function that returns a new semaphore object. A semaphore manages "
|
||
"a counter representing the number of :meth:`release` calls minus the number "
|
||
"of :meth:`acquire` calls, plus an initial value. The :meth:`acquire` method "
|
||
"blocks if necessary until it can return without making the counter "
|
||
"negative. If not given, *value* defaults to 1."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:141
|
||
msgid "See :ref:`semaphore-objects`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:146
|
||
msgid ""
|
||
"A factory function that returns a new bounded semaphore object. A bounded "
|
||
"semaphore checks to make sure its current value doesn't exceed its initial "
|
||
"value. If it does, :exc:`ValueError` is raised. In most situations "
|
||
"semaphores are used to guard resources with limited capacity. If the "
|
||
"semaphore is released too many times it's a sign of a bug. If not given, "
|
||
"*value* defaults to 1."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:156
|
||
msgid ""
|
||
"A class that represents a thread of control. This class can be safely "
|
||
"subclassed in a limited fashion."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:159
|
||
msgid "See :ref:`thread-objects`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:165
|
||
msgid ""
|
||
"A thread that executes a function after a specified interval has passed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:167
|
||
msgid "See :ref:`timer-objects`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:174
|
||
msgid ""
|
||
"Set a trace function for all threads started from the :mod:`threading` "
|
||
"module. The *func* will be passed to :func:`sys.settrace` for each thread, "
|
||
"before its :meth:`~Thread.run` method is called."
|
||
msgstr ""
|
||
"Attache une fonction de traçage pour tous les fils d'exécution démarrés "
|
||
"depuis le module :mod:`Thread`. La fonction *func* est passée à :func:`sys."
|
||
"settrace` pour chaque fil, avant que sa méthode :meth:`~Thread.run` soit "
|
||
"appelée."
|
||
|
||
#: ../Doc/library/threading.rst:185
|
||
msgid ""
|
||
"Set a profile function for all threads started from the :mod:`threading` "
|
||
"module. The *func* will be passed to :func:`sys.setprofile` for each "
|
||
"thread, before its :meth:`~Thread.run` method is called."
|
||
msgstr ""
|
||
"Attache une fonction de profilage pour tous les fils d'exécution démarrés "
|
||
"depuis le module :mod:`Threading`. La fonction *func* est passée à :func:"
|
||
"`sys.setprofile` pour chaque fil, avant que sa méthode :meth:`~Thread.run` "
|
||
"soit appelée."
|
||
|
||
#: ../Doc/library/threading.rst:194
|
||
msgid ""
|
||
"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 :exc:"
|
||
"`ThreadError` is raised. If the specified stack size is invalid, a :exc:"
|
||
"`ValueError` is raised and the stack size is unmodified. 32kB 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 > 32kB or requiring allocation in multiples of the system memory page "
|
||
"size - platform documentation should be referred to for more information "
|
||
"(4kB 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."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:215
|
||
msgid ""
|
||
"Raised for various threading-related errors as described below. Note that "
|
||
"many interfaces use :exc:`RuntimeError` instead of :exc:`ThreadError`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:219
|
||
msgid "Detailed interfaces for the objects are documented below."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:221
|
||
msgid ""
|
||
"The design of this module is loosely based on Java's threading model. "
|
||
"However, where Java makes locks and condition variables basic behavior of "
|
||
"every object, they are separate objects in Python. Python's :class:`Thread` "
|
||
"class supports a subset of the behavior of Java's Thread class; currently, "
|
||
"there are no priorities, no thread groups, and threads cannot be destroyed, "
|
||
"stopped, suspended, resumed, or interrupted. The static methods of Java's "
|
||
"Thread class, when implemented, are mapped to module-level functions."
|
||
msgstr ""
|
||
"La conception de ce module est librement basée sur le modèle des fils "
|
||
"d'exécution de Java. Cependant, là où Java fait des verrous et des variables "
|
||
"de condition le comportement de base de chaque objet, ils sont des objets "
|
||
"séparés en Python. La classe Python :class:`Thread` prend en charge un sous-"
|
||
"ensemble du comportement de la classe *Thread* de Java ; actuellement, il "
|
||
"n'y a aucune priorité, aucun groupe de fils d'exécution, et les fils ne "
|
||
"peuvent être détruits, arrêtés, suspendus, repris ni interrompus. Les "
|
||
"méthodes statiques de la classe *Thread* de Java, lorsqu'elles sont "
|
||
"implémentées, correspondent à des fonctions au niveau du module."
|
||
|
||
#: ../Doc/library/threading.rst:229
|
||
msgid "All of the methods described below are executed atomically."
|
||
msgstr ""
|
||
"Toutes les méthodes décrites ci-dessous sont exécutées de manière atomique."
|
||
|
||
#: ../Doc/library/threading.rst:235
|
||
msgid "Thread Objects"
|
||
msgstr "Objets *Threads*"
|
||
|
||
#: ../Doc/library/threading.rst:237
|
||
msgid ""
|
||
"This class represents an activity that is run in a separate thread of "
|
||
"control. There are two ways to specify the activity: by passing a callable "
|
||
"object to the constructor, or by overriding the :meth:`run` method in a "
|
||
"subclass. No other methods (except for the constructor) should be "
|
||
"overridden in a subclass. In other words, *only* override the :meth:"
|
||
"`__init__` and :meth:`run` methods of this class."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:244
|
||
msgid ""
|
||
"Once a thread object is created, its activity must be started by calling the "
|
||
"thread's :meth:`start` method. This invokes the :meth:`run` method in a "
|
||
"separate thread of control."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:248
|
||
msgid ""
|
||
"Once the thread's activity is started, the thread is considered 'alive'. It "
|
||
"stops being alive when its :meth:`run` method terminates -- either normally, "
|
||
"or by raising an unhandled exception. The :meth:`is_alive` method tests "
|
||
"whether the thread is alive."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:253
|
||
msgid ""
|
||
"Other threads can call a thread's :meth:`join` method. This blocks the "
|
||
"calling thread until the thread whose :meth:`join` method is called is "
|
||
"terminated."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:256
|
||
msgid ""
|
||
"A thread has a name. The name can be passed to the constructor, and read or "
|
||
"changed through the :attr:`name` attribute."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:259
|
||
msgid ""
|
||
"A thread can be flagged as a \"daemon thread\". The significance of this "
|
||
"flag is that the entire Python program exits when only daemon threads are "
|
||
"left. The initial value is inherited from the creating thread. The flag "
|
||
"can be set through the :attr:`daemon` property."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:265
|
||
msgid ""
|
||
"Daemon threads are abruptly stopped at shutdown. Their resources (such as "
|
||
"open files, database transactions, etc.) may not be released properly. If "
|
||
"you want your threads to stop gracefully, make them non-daemonic and use a "
|
||
"suitable signalling mechanism such as an :class:`Event`."
|
||
msgstr ""
|
||
"Les fils d'exécution démons sont brusquement terminés à l'arrêt du programme "
|
||
"Python. Leurs ressources (fichiers ouverts, transactions de base de données, "
|
||
"etc.) peuvent ne pas être libérées correctement. Si vous voulez que vos fils "
|
||
"s'arrêtent proprement, faites en sorte qu'ils ne soient pas démoniques et "
|
||
"utilisez un mécanisme de signalisation approprié tel qu'un objet évènement :"
|
||
"class:`Event`."
|
||
|
||
#: ../Doc/library/threading.rst:270
|
||
msgid ""
|
||
"There is a \"main thread\" object; this corresponds to the initial thread of "
|
||
"control in the Python program. It is not a daemon thread."
|
||
msgstr ""
|
||
"Il y a un objet \"fil principal\", qui correspond au fil de contrôle initial "
|
||
"dans le programme Python. Ce n'est pas un fil démon."
|
||
|
||
#: ../Doc/library/threading.rst:273
|
||
msgid ""
|
||
"There is the possibility that \"dummy thread objects\" are created. These "
|
||
"are thread objects corresponding to \"alien threads\", which are threads of "
|
||
"control started outside the threading module, such as directly from C code. "
|
||
"Dummy thread objects have limited functionality; they are always considered "
|
||
"alive and daemonic, and cannot be :meth:`join`\\ ed. They are never "
|
||
"deleted, since it is impossible to detect the termination of alien threads."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:283
|
||
msgid ""
|
||
"This constructor should always be called with keyword arguments. Arguments "
|
||
"are:"
|
||
msgstr ""
|
||
"Ce constructeur doit toujours être appelé avec des arguments nommés. Les "
|
||
"arguments sont :"
|
||
|
||
#: ../Doc/library/threading.rst:286
|
||
msgid ""
|
||
"*group* should be ``None``; reserved for future extension when a :class:"
|
||
"`ThreadGroup` class is implemented."
|
||
msgstr ""
|
||
"*group* doit être ``None`` ; cet argument est réservé pour une extension "
|
||
"future lorsqu'une classe :class:`ThreadGroup` sera implémentée."
|
||
|
||
#: ../Doc/library/threading.rst:289
|
||
msgid ""
|
||
"*target* is the callable object to be invoked by the :meth:`run` method. "
|
||
"Defaults to ``None``, meaning nothing is called."
|
||
msgstr ""
|
||
"*target* est l'objet appelable qui doit être invoqué par la méthode :meth:"
|
||
"`run`. La valeur par défaut est ``None``, ce qui signifie que rien n'est "
|
||
"appelé."
|
||
|
||
#: ../Doc/library/threading.rst:292
|
||
msgid ""
|
||
"*name* is the thread name. By default, a unique name is constructed of the "
|
||
"form \"Thread-*N*\" where *N* is a small decimal number."
|
||
msgstr ""
|
||
"*name* est le nom du fil d'exécution. Par défaut, un nom unique est "
|
||
"construit de la forme « Thread–*N* » où *N* est un petit nombre décimal."
|
||
|
||
#: ../Doc/library/threading.rst:295
|
||
msgid ""
|
||
"*args* is the argument tuple for the target invocation. Defaults to ``()``."
|
||
msgstr ""
|
||
"*args* est le tuple d'arguments pour l'invocation de l'objet appelable. La "
|
||
"valeur par défaut est ``()``."
|
||
|
||
#: ../Doc/library/threading.rst:297
|
||
msgid ""
|
||
"*kwargs* is a dictionary of keyword arguments for the target invocation. "
|
||
"Defaults to ``{}``."
|
||
msgstr ""
|
||
"*kwargs* est un dictionnaire d'arguments nommés pour l'invocation de l'objet "
|
||
"appelable. La valeur par défaut est ``{}``."
|
||
|
||
#: ../Doc/library/threading.rst:300
|
||
msgid ""
|
||
"If the subclass overrides the constructor, it must make sure to invoke the "
|
||
"base class constructor (``Thread.__init__()``) before doing anything else to "
|
||
"the thread."
|
||
msgstr ""
|
||
"Si la sous-classe réimplémente le constructeur, elle doit s'assurer "
|
||
"d'appeler le constructeur de la classe de base (``Thread.__init__()``) avant "
|
||
"de faire autre chose au fil d'exécution."
|
||
|
||
#: ../Doc/library/threading.rst:306
|
||
msgid "Start the thread's activity."
|
||
msgstr "Lance l'activité du fil d'exécution."
|
||
|
||
#: ../Doc/library/threading.rst:308
|
||
msgid ""
|
||
"It must be called at most once per thread object. It arranges for the "
|
||
"object's :meth:`run` method to be invoked in a separate thread of control."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:311
|
||
msgid ""
|
||
"This method will raise a :exc:`RuntimeError` if called more than once on the "
|
||
"same thread object."
|
||
msgstr ""
|
||
"Cette méthode lève une :exc:`RuntimeError` si elle est appelée plus d'une "
|
||
"fois sur le même objet fil d'exécution."
|
||
|
||
#: ../Doc/library/threading.rst:316
|
||
msgid "Method representing the thread's activity."
|
||
msgstr "Méthode représentant l'activité du fil d'exécution."
|
||
|
||
#: ../Doc/library/threading.rst:318
|
||
msgid ""
|
||
"You may override this method in a subclass. The standard :meth:`run` method "
|
||
"invokes the callable object passed to the object's constructor as the "
|
||
"*target* argument, if any, with sequential and keyword arguments taken from "
|
||
"the *args* and *kwargs* arguments, respectively."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:325
|
||
msgid ""
|
||
"Wait until the thread terminates. This blocks the calling thread until the "
|
||
"thread whose :meth:`join` method is called terminates -- either normally or "
|
||
"through an unhandled exception -- or until the optional timeout occurs."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:329
|
||
msgid ""
|
||
"When the *timeout* argument is present and not ``None``, it should be a "
|
||
"floating point number specifying a timeout for the operation in seconds (or "
|
||
"fractions thereof). As :meth:`join` always returns ``None``, you must call :"
|
||
"meth:`isAlive` after :meth:`join` to decide whether a timeout happened -- if "
|
||
"the thread is still alive, the :meth:`join` call timed out."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:335
|
||
msgid ""
|
||
"When the *timeout* argument is not present or ``None``, the operation will "
|
||
"block until the thread terminates."
|
||
msgstr ""
|
||
"Lorsque l'argument *timeout* n'est pas présent ou vaut ``None``, l'opération "
|
||
"se bloque jusqu'à ce que le fil d'exécution se termine."
|
||
|
||
#: ../Doc/library/threading.rst:338
|
||
msgid "A thread can be :meth:`join`\\ ed many times."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:340
|
||
msgid ""
|
||
":meth:`join` raises a :exc:`RuntimeError` if an attempt is made to join the "
|
||
"current thread as that would cause a deadlock. It is also an error to :meth:"
|
||
"`join` a thread before it has been started and attempts to do so raises the "
|
||
"same exception."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:347
|
||
msgid ""
|
||
"A string used for identification purposes only. It has no semantics. "
|
||
"Multiple threads may be given the same name. The initial name is set by the "
|
||
"constructor."
|
||
msgstr ""
|
||
"Une chaîne de caractères utilisée à des fins d'identification seulement. "
|
||
"Elle n'a pas de sémantique. Plusieurs fils d'exécution peuvent porter le "
|
||
"même nom. Le nom initial est défini par le constructeur."
|
||
|
||
#: ../Doc/library/threading.rst:356
|
||
msgid "Pre-2.6 API for :attr:`~Thread.name`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:360
|
||
msgid ""
|
||
"The 'thread identifier' of this thread or ``None`` if the thread has not "
|
||
"been started. This is a nonzero integer. See the :func:`thread."
|
||
"get_ident()` function. Thread identifiers may be recycled when a thread "
|
||
"exits and another thread is created. The identifier is available even after "
|
||
"the thread has exited."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:371
|
||
msgid "Return whether the thread is alive."
|
||
msgstr "Renvoie si le fil d'exécution est vivant ou pas."
|
||
|
||
#: ../Doc/library/threading.rst:373
|
||
msgid ""
|
||
"This method returns ``True`` just before the :meth:`run` method starts until "
|
||
"just after the :meth:`run` method terminates. The module function :func:`."
|
||
"enumerate` returns a list of all alive threads."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:377
|
||
msgid "Added ``is_alive()`` spelling."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:382
|
||
msgid ""
|
||
"A boolean value indicating whether this thread is a daemon thread (True) or "
|
||
"not (False). This must be set before :meth:`start` is called, otherwise :"
|
||
"exc:`RuntimeError` is raised. Its initial value is inherited from the "
|
||
"creating thread; the main thread is not a daemon thread and therefore all "
|
||
"threads created in the main thread default to :attr:`daemon` = ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:389
|
||
msgid ""
|
||
"The entire Python program exits when no alive non-daemon threads are left."
|
||
msgstr ""
|
||
"Le programme Python se termine lorsqu'il ne reste plus de fils d'exécution "
|
||
"non-démons vivants."
|
||
|
||
#: ../Doc/library/threading.rst:396
|
||
msgid "Pre-2.6 API for :attr:`~Thread.daemon`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:402
|
||
msgid "Lock Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:404
|
||
msgid ""
|
||
"A primitive lock is a synchronization primitive that is not owned by a "
|
||
"particular thread when locked. In Python, it is currently the lowest level "
|
||
"synchronization primitive available, implemented directly by the :mod:"
|
||
"`thread` extension module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:409
|
||
msgid ""
|
||
"A primitive lock is in one of two states, \"locked\" or \"unlocked\". It is "
|
||
"created in the unlocked state. It has two basic methods, :meth:`acquire` "
|
||
"and :meth:`release`. When the state is unlocked, :meth:`acquire` changes "
|
||
"the state to locked and returns immediately. When the state is locked, :"
|
||
"meth:`acquire` blocks until a call to :meth:`release` in another thread "
|
||
"changes it to unlocked, then the :meth:`acquire` call resets it to locked "
|
||
"and returns. The :meth:`release` method should only be called in the locked "
|
||
"state; it changes the state to unlocked and returns immediately. If an "
|
||
"attempt is made to release an unlocked lock, a :exc:`ThreadError` will be "
|
||
"raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:419
|
||
msgid ""
|
||
"When more than one thread is blocked in :meth:`acquire` waiting for the "
|
||
"state to turn to unlocked, only one thread proceeds when a :meth:`release` "
|
||
"call resets the state to unlocked; which one of the waiting threads proceeds "
|
||
"is not defined, and may vary across implementations."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:424
|
||
msgid "All methods are executed atomically."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:429 ../Doc/library/threading.rst:473
|
||
msgid "Acquire a lock, blocking or non-blocking."
|
||
msgstr "Acquiert un verrou, bloquant ou non bloquant."
|
||
|
||
#: ../Doc/library/threading.rst:431
|
||
msgid ""
|
||
"When invoked with the *blocking* argument set to ``True`` (the default), "
|
||
"block until the lock is unlocked, then set it to locked and return ``True``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:434
|
||
msgid ""
|
||
"When invoked with the *blocking* argument set to ``False``, do not block. If "
|
||
"a call with *blocking* set to ``True`` would block, return ``False`` "
|
||
"immediately; otherwise, set the lock to locked and return ``True``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:441
|
||
msgid "Release a lock."
|
||
msgstr "Libère un verrou."
|
||
|
||
#: ../Doc/library/threading.rst:443
|
||
msgid ""
|
||
"When the lock is locked, reset it to unlocked, and return. If any other "
|
||
"threads are blocked waiting for the lock to become unlocked, allow exactly "
|
||
"one of them to proceed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:447
|
||
msgid "When invoked on an unlocked lock, a :exc:`ThreadError` is raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:449 ../Doc/library/threading.rst:503
|
||
msgid "There is no return value."
|
||
msgstr "Il n'y a pas de valeur de retour."
|
||
|
||
#: ../Doc/library/threading.rst:455
|
||
msgid "RLock Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:457
|
||
msgid ""
|
||
"A reentrant lock is a synchronization primitive that may be acquired "
|
||
"multiple times by the same thread. Internally, it uses the concepts of "
|
||
"\"owning thread\" and \"recursion level\" in addition to the locked/unlocked "
|
||
"state used by primitive locks. In the locked state, some thread owns the "
|
||
"lock; in the unlocked state, no thread owns it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:463
|
||
msgid ""
|
||
"To lock the lock, a thread calls its :meth:`acquire` method; this returns "
|
||
"once the thread owns the lock. To unlock the lock, a thread calls its :meth:"
|
||
"`release` method. :meth:`acquire`/:meth:`release` call pairs may be nested; "
|
||
"only the final :meth:`release` (the :meth:`release` of the outermost pair) "
|
||
"resets the lock to unlocked and allows another thread blocked in :meth:"
|
||
"`acquire` to proceed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:475
|
||
msgid ""
|
||
"When invoked without arguments: if this thread already owns the lock, "
|
||
"increment the recursion level by one, and return immediately. Otherwise, if "
|
||
"another thread owns the lock, block until the lock is unlocked. Once the "
|
||
"lock is unlocked (not owned by any thread), then grab ownership, set the "
|
||
"recursion level to one, and return. If more than one thread is blocked "
|
||
"waiting until the lock is unlocked, only one at a time will be able to grab "
|
||
"ownership of the lock. There is no return value in this case."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:483
|
||
msgid ""
|
||
"When invoked with the *blocking* argument set to true, do the same thing as "
|
||
"when called without arguments, and return true."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:486
|
||
msgid ""
|
||
"When invoked with the *blocking* argument set to false, do not block. If a "
|
||
"call without an argument would block, return false immediately; otherwise, "
|
||
"do the same thing as when called without arguments, and return true."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:493
|
||
msgid ""
|
||
"Release a lock, decrementing the recursion level. If after the decrement it "
|
||
"is zero, reset the lock to unlocked (not owned by any thread), and if any "
|
||
"other threads are blocked waiting for the lock to become unlocked, allow "
|
||
"exactly one of them to proceed. If after the decrement the recursion level "
|
||
"is still nonzero, the lock remains locked and owned by the calling thread."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:499
|
||
msgid ""
|
||
"Only call this method when the calling thread owns the lock. A :exc:"
|
||
"`RuntimeError` is raised if this method is called when the lock is unlocked."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:509
|
||
msgid "Condition Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:511
|
||
msgid ""
|
||
"A condition variable is always associated with some kind of lock; this can "
|
||
"be passed in or one will be created by default. (Passing one in is useful "
|
||
"when several condition variables must share the same lock.)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:515
|
||
msgid ""
|
||
"A condition variable has :meth:`acquire` and :meth:`release` methods that "
|
||
"call the corresponding methods of the associated lock. It also has a :meth:"
|
||
"`wait` method, and :meth:`notify` and :meth:`notifyAll` methods. These "
|
||
"three must only be called when the calling thread has acquired the lock, "
|
||
"otherwise a :exc:`RuntimeError` is raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:521
|
||
msgid ""
|
||
"The :meth:`wait` method releases the lock, and then blocks until it is "
|
||
"awakened by a :meth:`notify` or :meth:`notifyAll` call for the same "
|
||
"condition variable in another thread. Once awakened, it re-acquires the "
|
||
"lock and returns. It is also possible to specify a timeout."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:526
|
||
msgid ""
|
||
"The :meth:`notify` method wakes up one of the threads waiting for the "
|
||
"condition variable, if any are waiting. The :meth:`notifyAll` method wakes "
|
||
"up all threads waiting for the condition variable."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:530
|
||
msgid ""
|
||
"Note: the :meth:`notify` and :meth:`notifyAll` methods don't release the "
|
||
"lock; this means that the thread or threads awakened will not return from "
|
||
"their :meth:`wait` call immediately, but only when the thread that called :"
|
||
"meth:`notify` or :meth:`notifyAll` finally relinquishes ownership of the "
|
||
"lock."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:535
|
||
msgid ""
|
||
"Tip: the typical programming style using condition variables uses the lock "
|
||
"to synchronize access to some shared state; threads that are interested in a "
|
||
"particular change of state call :meth:`wait` repeatedly until they see the "
|
||
"desired state, while threads that modify the state call :meth:`notify` or :"
|
||
"meth:`notifyAll` when they change the state in such a way that it could "
|
||
"possibly be a desired state for one of the waiters. For example, the "
|
||
"following code is a generic producer-consumer situation with unlimited "
|
||
"buffer capacity::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:556
|
||
msgid ""
|
||
"To choose between :meth:`notify` and :meth:`notifyAll`, consider whether one "
|
||
"state change can be interesting for only one or several waiting threads. E."
|
||
"g. in a typical producer-consumer situation, adding one item to the buffer "
|
||
"only needs to wake up one consumer thread."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:564
|
||
msgid ""
|
||
"If the *lock* argument is given and not ``None``, it must be a :class:`Lock` "
|
||
"or :class:`RLock` object, and it is used as the underlying lock. Otherwise, "
|
||
"a new :class:`RLock` object is created and used as the underlying lock."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:570
|
||
msgid ""
|
||
"Acquire the underlying lock. This method calls the corresponding method on "
|
||
"the underlying lock; the return value is whatever that method returns."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:575
|
||
msgid ""
|
||
"Release the underlying lock. This method calls the corresponding method on "
|
||
"the underlying lock; there is no return value."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:580
|
||
msgid ""
|
||
"Wait until notified or until a timeout occurs. If the calling thread has not "
|
||
"acquired the lock when this method is called, a :exc:`RuntimeError` is "
|
||
"raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:583
|
||
msgid ""
|
||
"This method releases the underlying lock, and then blocks until it is "
|
||
"awakened by a :meth:`notify` or :meth:`notifyAll` call for the same "
|
||
"condition variable in another thread, or until the optional timeout occurs. "
|
||
"Once awakened or timed out, it re-acquires the lock and returns."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:588
|
||
msgid ""
|
||
"When the *timeout* argument is present and not ``None``, it should be a "
|
||
"floating point number specifying a timeout for the operation in seconds (or "
|
||
"fractions thereof)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:592
|
||
msgid ""
|
||
"When the underlying lock is an :class:`RLock`, it is not released using its :"
|
||
"meth:`release` method, since this may not actually unlock the lock when it "
|
||
"was acquired multiple times recursively. Instead, an internal interface of "
|
||
"the :class:`RLock` class is used, which really unlocks it even when it has "
|
||
"been recursively acquired several times. Another internal interface is then "
|
||
"used to restore the recursion level when the lock is reacquired."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:602
|
||
msgid ""
|
||
"By default, wake up one thread waiting on this condition, if any. If the "
|
||
"calling thread has not acquired the lock when this method is called, a :exc:"
|
||
"`RuntimeError` is raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:606
|
||
msgid ""
|
||
"This method wakes up at most *n* of the threads waiting for the condition "
|
||
"variable; it is a no-op if no threads are waiting."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:609
|
||
msgid ""
|
||
"The current implementation wakes up exactly *n* threads, if at least *n* "
|
||
"threads are waiting. However, it's not safe to rely on this behavior. A "
|
||
"future, optimized implementation may occasionally wake up more than *n* "
|
||
"threads."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:614
|
||
msgid ""
|
||
"Note: an awakened thread does not actually return from its :meth:`wait` call "
|
||
"until it can reacquire the lock. Since :meth:`notify` does not release the "
|
||
"lock, its caller should."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:621
|
||
msgid ""
|
||
"Wake up all threads waiting on this condition. This method acts like :meth:"
|
||
"`notify`, but wakes up all waiting threads instead of one. If the calling "
|
||
"thread has not acquired the lock when this method is called, a :exc:"
|
||
"`RuntimeError` is raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:626
|
||
msgid "Added ``notify_all()`` spelling."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:633
|
||
msgid "Semaphore Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:635
|
||
msgid ""
|
||
"This is one of the oldest synchronization primitives in the history of "
|
||
"computer science, invented by the early Dutch computer scientist Edsger W. "
|
||
"Dijkstra (he used :meth:`P` and :meth:`V` instead of :meth:`acquire` and :"
|
||
"meth:`release`)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:639
|
||
msgid ""
|
||
"A semaphore manages an internal counter which is decremented by each :meth:"
|
||
"`acquire` call and incremented by each :meth:`release` call. The counter "
|
||
"can never go below zero; when :meth:`acquire` finds that it is zero, it "
|
||
"blocks, waiting until some other thread calls :meth:`release`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:647
|
||
msgid ""
|
||
"The optional argument gives the initial *value* for the internal counter; it "
|
||
"defaults to ``1``. If the *value* given is less than 0, :exc:`ValueError` is "
|
||
"raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:653
|
||
msgid "Acquire a semaphore."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:655
|
||
msgid ""
|
||
"When invoked without arguments: if the internal counter is larger than zero "
|
||
"on entry, decrement it by one and return immediately. If it is zero on "
|
||
"entry, block, waiting until some other thread has called :meth:`release` to "
|
||
"make it larger than zero. This is done with proper interlocking so that if "
|
||
"multiple :meth:`acquire` calls are blocked, :meth:`release` will wake "
|
||
"exactly one of them up. The implementation may pick one at random, so the "
|
||
"order in which blocked threads are awakened should not be relied on. There "
|
||
"is no return value in this case."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:664
|
||
msgid ""
|
||
"When invoked with *blocking* set to true, do the same thing as when called "
|
||
"without arguments, and return true."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:667
|
||
msgid ""
|
||
"When invoked with *blocking* set to false, do not block. If a call without "
|
||
"an argument would block, return false immediately; otherwise, do the same "
|
||
"thing as when called without arguments, and return true."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:673
|
||
msgid ""
|
||
"Release a semaphore, incrementing the internal counter by one. When it was "
|
||
"zero on entry and another thread is waiting for it to become larger than "
|
||
"zero again, wake up that thread."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:681
|
||
msgid ":class:`Semaphore` Example"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:683
|
||
msgid ""
|
||
"Semaphores are often used to guard resources with limited capacity, for "
|
||
"example, a database server. In any situation where the size of the resource "
|
||
"is fixed, you should use a bounded semaphore. Before spawning any worker "
|
||
"threads, your main thread would initialize the semaphore::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:692
|
||
msgid ""
|
||
"Once spawned, worker threads call the semaphore's acquire and release "
|
||
"methods when they need to connect to the server::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:701
|
||
msgid ""
|
||
"The use of a bounded semaphore reduces the chance that a programming error "
|
||
"which causes the semaphore to be released more than it's acquired will go "
|
||
"undetected."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:708
|
||
msgid "Event Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:710
|
||
msgid ""
|
||
"This is one of the simplest mechanisms for communication between threads: "
|
||
"one thread signals an event and other threads wait for it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:713
|
||
msgid ""
|
||
"An event object manages an internal flag that can be set to true with the :"
|
||
"meth:`~Event.set` method and reset to false with the :meth:`~Event.clear` "
|
||
"method. The :meth:`~Event.wait` method blocks until the flag is true."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:720
|
||
msgid "The internal flag is initially false."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:725
|
||
msgid "Return true if and only if the internal flag is true."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:727
|
||
msgid "Added ``is_set()`` spelling."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:732
|
||
msgid ""
|
||
"Set the internal flag to true. All threads waiting for it to become true are "
|
||
"awakened. Threads that call :meth:`wait` once the flag is true will not "
|
||
"block at all."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:738
|
||
msgid ""
|
||
"Reset the internal flag to false. Subsequently, threads calling :meth:`wait` "
|
||
"will block until :meth:`.set` is called to set the internal flag to true "
|
||
"again."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:744
|
||
msgid ""
|
||
"Block until the internal flag is true. If the internal flag is true on "
|
||
"entry, return immediately. Otherwise, block until another thread calls :"
|
||
"meth:`.set` to set the flag to true, or until the optional timeout occurs."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:749
|
||
msgid ""
|
||
"When the timeout argument is present and not ``None``, it should be a "
|
||
"floating point number specifying a timeout for the operation in seconds (or "
|
||
"fractions thereof)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:753
|
||
msgid ""
|
||
"This method returns the internal flag on exit, so it will always return "
|
||
"``True`` except if a timeout is given and the operation times out."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:756
|
||
msgid "Previously, the method always returned ``None``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:763
|
||
msgid "Timer Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:765
|
||
msgid ""
|
||
"This class represents an action that should be run only after a certain "
|
||
"amount of time has passed --- a timer. :class:`Timer` is a subclass of :"
|
||
"class:`Thread` and as such also functions as an example of creating custom "
|
||
"threads."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:769
|
||
msgid ""
|
||
"Timers are started, as with threads, by calling their :meth:`~Timer.start` "
|
||
"method. The timer can be stopped (before its action has begun) by calling "
|
||
"the :meth:`~Timer.cancel` method. The interval the timer will wait before "
|
||
"executing its action may not be exactly the same as the interval specified "
|
||
"by the user."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:775
|
||
msgid "For example::"
|
||
msgstr "Par exemple ::"
|
||
|
||
#: ../Doc/library/threading.rst:786
|
||
msgid ""
|
||
"Create a timer that will run *function* with arguments *args* and keyword "
|
||
"arguments *kwargs*, after *interval* seconds have passed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:791
|
||
msgid ""
|
||
"Stop the timer, and cancel the execution of the timer's action. This will "
|
||
"only work if the timer is still in its waiting stage."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:798
|
||
msgid ""
|
||
"Using locks, conditions, and semaphores in the :keyword:`with` statement"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:800
|
||
msgid ""
|
||
"All of the objects provided by this module that have :meth:`acquire` and :"
|
||
"meth:`release` methods can be used as context managers for a :keyword:`with` "
|
||
"statement. The :meth:`acquire` method will be called when the block is "
|
||
"entered, and :meth:`release` will be called when the block is exited."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:805
|
||
msgid ""
|
||
"Currently, :class:`Lock`, :class:`RLock`, :class:`Condition`, :class:"
|
||
"`Semaphore`, and :class:`BoundedSemaphore` objects may be used as :keyword:"
|
||
"`with` statement context managers. For example::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:820
|
||
msgid "Importing in threaded code"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:822
|
||
msgid ""
|
||
"While the import machinery is thread-safe, there are two key restrictions on "
|
||
"threaded imports due to inherent limitations in the way that thread-safety "
|
||
"is provided:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:826
|
||
msgid ""
|
||
"Firstly, other than in the main module, an import should not have the side "
|
||
"effect of spawning a new thread and then waiting for that thread in any way. "
|
||
"Failing to abide by this restriction can lead to a deadlock if the spawned "
|
||
"thread directly or indirectly attempts to import a module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/threading.rst:830
|
||
msgid ""
|
||
"Secondly, all import attempts must be completed before the interpreter "
|
||
"starts shutting itself down. This can be most easily achieved by only "
|
||
"performing imports from non-daemon threads created through the threading "
|
||
"module. Daemon threads and threads created directly with the thread module "
|
||
"will require some other form of synchronization to ensure they do not "
|
||
"attempt imports after system shutdown has commenced. Failure to abide by "
|
||
"this restriction will lead to intermittent exceptions and crashes during "
|
||
"interpreter shutdown (as the late imports attempt to access machinery which "
|
||
"is no longer in a valid state)."
|
||
msgstr ""
|