python-docs-fr/library/threading.po

# 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 "Verrous"

#: ../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 ""