# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-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 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-01-04 15:51+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"
"Language: fr\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` --- Thread-based parallelism"
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:`queue` module."
msgstr ""

#: ../Doc/library/threading.rst:14
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:19
msgid ""
"While they are not listed below, the ``camelCase`` names used for some "
"methods and functions in this module in the Python 2.x series are still "
"supported by this module."
msgstr ""

#: ../Doc/library/threading.rst:24
msgid "This module defines the following functions:"
msgstr ""

#: ../Doc/library/threading.rst:29
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 ""

#: ../Doc/library/threading.rst:35
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 ""

#: ../Doc/library/threading.rst:43
msgid ""
"Return the 'thread identifier' of the current thread.  This is a nonzero "
"integer.  Its value has no direct meaning; it is intended as a magic cookie "
"to be used e.g. to index a dictionary of thread-specific data.  Thread "
"identifiers may be recycled when a thread exits and another thread is "
"created."
msgstr ""

#: ../Doc/library/threading.rst:54
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 ""

#: ../Doc/library/threading.rst:62
msgid ""
"Return the main :class:`Thread` object.  In normal conditions, the main "
"thread is the thread from which the Python interpreter was started."
msgstr ""

#: ../Doc/library/threading.rst:73
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 ""

#: ../Doc/library/threading.rst:82
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 ""

#: ../Doc/library/threading.rst:89
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:"
"`RuntimeError` is raised.  If the specified stack size is invalid, a :exc:"
"`ValueError` is raised and the stack size is unmodified.  32 KiB is "
"currently the minimum supported stack size value to guarantee sufficient "
"stack space for the interpreter itself.  Note that some platforms may have "
"particular restrictions on values for the stack size, such as requiring a "
"minimum stack size > 32 KiB or requiring allocation in multiples of the "
"system memory page size - platform documentation should be referred to for "
"more information (4 KiB pages are common; using multiples of 4096 for the "
"stack size is the suggested approach in the absence of more specific "
"information). Availability: Windows, systems with POSIX threads."
msgstr ""

#: ../Doc/library/threading.rst:106
msgid "This module also defines the following constant:"
msgstr ""

#: ../Doc/library/threading.rst:110
msgid ""
"The maximum value allowed for the *timeout* parameter of blocking functions "
"(:meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Condition.wait`, etc.). "
"Specifying a timeout greater than this value will raise an :exc:"
"`OverflowError`."
msgstr ""

#: ../Doc/library/threading.rst:118
msgid ""
"This module defines a number of classes, which are detailed in the sections "
"below."
msgstr ""

#: ../Doc/library/threading.rst:121
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 ""

#: ../Doc/library/threading.rst:129
msgid "All of the methods described below are executed atomically."
msgstr ""

#: ../Doc/library/threading.rst:133
msgid "Thread-Local Data"
msgstr ""

#: ../Doc/library/threading.rst:135
msgid ""
"Thread-local data is 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:142
msgid "The instance's values will be different for separate threads."
msgstr ""

#: ../Doc/library/threading.rst:147
msgid "A class that represents thread-local data."
msgstr ""

#: ../Doc/library/threading.rst:149
msgid ""
"For more details and extensive examples, see the documentation string of "
"the :mod:`_threading_local` module."
msgstr ""

#: ../Doc/library/threading.rst:156
msgid "Thread Objects"
msgstr ""

#: ../Doc/library/threading.rst:158
msgid ""
"The :class:`Thread` 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:`~Thread.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:"
"`~Thread.__init__` and :meth:`~Thread.run` methods of this class."
msgstr ""

#: ../Doc/library/threading.rst:165
msgid ""
"Once a thread object is created, its activity must be started by calling the "
"thread's :meth:`~Thread.start` method.  This invokes the :meth:`~Thread.run` "
"method in a separate thread of control."
msgstr ""

#: ../Doc/library/threading.rst:169
msgid ""
"Once the thread's activity is started, the thread is considered 'alive'. It "
"stops being alive when its :meth:`~Thread.run` method terminates -- either "
"normally, or by raising an unhandled exception.  The :meth:`~Thread."
"is_alive` method tests whether the thread is alive."
msgstr ""

#: ../Doc/library/threading.rst:174
msgid ""
"Other threads can call a thread's :meth:`~Thread.join` method.  This blocks "
"the calling thread until the thread whose :meth:`~Thread.join` method is "
"called is terminated."
msgstr ""

#: ../Doc/library/threading.rst:178
msgid ""
"A thread has a name.  The name can be passed to the constructor, and read or "
"changed through the :attr:`~Thread.name` attribute."
msgstr ""

#: ../Doc/library/threading.rst:181
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:`~Thread.daemon` property or the *daemon* "
"constructor argument."
msgstr ""

#: ../Doc/library/threading.rst:188
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 ""

#: ../Doc/library/threading.rst:193
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 ""

#: ../Doc/library/threading.rst:196
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:`~Thread.join`\\ ed.  They are never "
"deleted, since it is impossible to detect the termination of alien threads."
msgstr ""

#: ../Doc/library/threading.rst:207
msgid ""
"This constructor should always be called with keyword arguments.  Arguments "
"are:"
msgstr ""

#: ../Doc/library/threading.rst:210
msgid ""
"*group* should be ``None``; reserved for future extension when a :class:"
"`ThreadGroup` class is implemented."
msgstr ""

#: ../Doc/library/threading.rst:213
msgid ""
"*target* is the callable object to be invoked by the :meth:`run` method. "
"Defaults to ``None``, meaning nothing is called."
msgstr ""

#: ../Doc/library/threading.rst:216
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 ""

#: ../Doc/library/threading.rst:219
msgid ""
"*args* is the argument tuple for the target invocation.  Defaults to ``()``."
msgstr ""

#: ../Doc/library/threading.rst:221
msgid ""
"*kwargs* is a dictionary of keyword arguments for the target invocation. "
"Defaults to ``{}``."
msgstr ""

#: ../Doc/library/threading.rst:224
msgid ""
"If not ``None``, *daemon* explicitly sets whether the thread is daemonic. If "
"``None`` (the default), the daemonic property is inherited from the current "
"thread."
msgstr ""

#: ../Doc/library/threading.rst:228
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 ""

#: ../Doc/library/threading.rst:232
msgid "Added the *daemon* argument."
msgstr ""

#: ../Doc/library/threading.rst:237
msgid "Start the thread's activity."
msgstr ""

#: ../Doc/library/threading.rst:239
msgid ""
"It must be called at most once per thread object.  It arranges for the "
"object's :meth:`~Thread.run` method to be invoked in a separate thread of "
"control."
msgstr ""

#: ../Doc/library/threading.rst:243
msgid ""
"This method will raise a :exc:`RuntimeError` if called more than once on the "
"same thread object."
msgstr ""

#: ../Doc/library/threading.rst:248
msgid "Method representing the thread's activity."
msgstr ""

#: ../Doc/library/threading.rst:250
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:257
msgid ""
"Wait until the thread terminates. This blocks the calling thread until the "
"thread whose :meth:`~Thread.join` method is called terminates -- either "
"normally or through an unhandled exception -- or until the optional timeout "
"occurs."
msgstr ""

#: ../Doc/library/threading.rst:262
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:`~Thread.join` always returns ``None``, you "
"must call :meth:`~Thread.is_alive` after :meth:`~Thread.join` to decide "
"whether a timeout happened -- if the thread is still alive, the :meth:"
"`~Thread.join` call timed out."
msgstr ""

#: ../Doc/library/threading.rst:269
msgid ""
"When the *timeout* argument is not present or ``None``, the operation will "
"block until the thread terminates."
msgstr ""

#: ../Doc/library/threading.rst:272
msgid "A thread can be :meth:`~Thread.join`\\ ed many times."
msgstr ""

#: ../Doc/library/threading.rst:274
msgid ""
":meth:`~Thread.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:`~Thread.join` a thread before it has been started and attempts to "
"do so raise the same exception."
msgstr ""

#: ../Doc/library/threading.rst:281
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 ""

#: ../Doc/library/threading.rst:288
msgid ""
"Old getter/setter API for :attr:`~Thread.name`; use it directly as a "
"property instead."
msgstr ""

#: ../Doc/library/threading.rst:293
msgid ""
"The 'thread identifier' of this thread or ``None`` if the thread has not "
"been started.  This is a nonzero integer.  See the :func:`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:301
msgid "Return whether the thread is alive."
msgstr ""

#: ../Doc/library/threading.rst:303
msgid ""
"This method returns ``True`` just before the :meth:`~Thread.run` method "
"starts until just after the :meth:`~Thread.run` method terminates.  The "
"module function :func:`.enumerate` returns a list of all alive threads."
msgstr ""

#: ../Doc/library/threading.rst:309
msgid ""
"A boolean value indicating whether this thread is a daemon thread (True) or "
"not (False).  This must be set before :meth:`~Thread.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:`~Thread."
"daemon` = ``False``."
msgstr ""

#: ../Doc/library/threading.rst:316
msgid ""
"The entire Python program exits when no alive non-daemon threads are left."
msgstr ""

#: ../Doc/library/threading.rst:321
msgid ""
"Old getter/setter API for :attr:`~Thread.daemon`; use it directly as a "
"property instead."
msgstr ""

#: ../Doc/library/threading.rst:327
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` or :class:`concurrent.futures."
"ProcessPoolExecutor`. However, threading is still an appropriate model if "
"you want to run multiple I/O-bound tasks simultaneously."
msgstr ""

#: ../Doc/library/threading.rst:340
msgid "Lock Objects"
msgstr ""

#: ../Doc/library/threading.rst:342
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:347
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:`~Lock."
"acquire` and :meth:`~Lock.release`.  When the state is unlocked, :meth:"
"`~Lock.acquire` changes the state to locked and returns immediately.  When "
"the state is locked, :meth:`~Lock.acquire` blocks until a call to :meth:"
"`~Lock.release` in another thread changes it to unlocked, then the :meth:"
"`~Lock.acquire` call resets it to locked and returns.  The :meth:`~Lock."
"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:`RuntimeError` will be raised."
msgstr ""

#: ../Doc/library/threading.rst:358
msgid "Locks also support the :ref:`context management protocol <with-locks>`."
msgstr ""

#: ../Doc/library/threading.rst:360
msgid ""
"When more than one thread is blocked in :meth:`~Lock.acquire` waiting for "
"the state to turn to unlocked, only one thread proceeds when a :meth:`~Lock."
"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:365
msgid "All methods are executed atomically."
msgstr ""

#: ../Doc/library/threading.rst:370
msgid ""
"The class implementing primitive lock objects.  Once a thread has acquired a "
"lock, subsequent attempts to acquire it block, until it is released; any "
"thread may release it."
msgstr ""

#: ../Doc/library/threading.rst:374
msgid ""
"Note that ``Lock`` is actually a factory function which returns an instance "
"of the most efficient version of the concrete Lock class that is supported "
"by the platform."
msgstr ""

#: ../Doc/library/threading.rst:381 ../Doc/library/threading.rst:455
msgid "Acquire a lock, blocking or non-blocking."
msgstr ""

#: ../Doc/library/threading.rst:383
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:386
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:390
msgid ""
"When invoked with the floating-point *timeout* argument set to a positive "
"value, block for at most the number of seconds specified by *timeout* and as "
"long as the lock cannot be acquired.  A *timeout* argument of ``-1`` "
"specifies an unbounded wait.  It is forbidden to specify a *timeout* when "
"*blocking* is false."
msgstr ""

#: ../Doc/library/threading.rst:396
msgid ""
"The return value is ``True`` if the lock is acquired successfully, ``False`` "
"if not (for example if the *timeout* expired)."
msgstr ""

#: ../Doc/library/threading.rst:399 ../Doc/library/threading.rst:477
#: ../Doc/library/threading.rst:722
msgid "The *timeout* parameter is new."
msgstr "Le paramètre *timeout* est nouveau."

#: ../Doc/library/threading.rst:402
msgid "Lock acquires can now be interrupted by signals on POSIX."
msgstr ""

#: ../Doc/library/threading.rst:408
msgid ""
"Release a lock.  This can be called from any thread, not only the thread "
"which has acquired the lock."
msgstr ""

#: ../Doc/library/threading.rst:411
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:415
msgid "When invoked on an unlocked lock, a :exc:`RuntimeError` is raised."
msgstr ""

#: ../Doc/library/threading.rst:417 ../Doc/library/threading.rst:493
msgid "There is no return value."
msgstr "Il n'y a pas de valeur de retour."

#: ../Doc/library/threading.rst:423
msgid "RLock Objects"
msgstr ""

#: ../Doc/library/threading.rst:425
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:431
msgid ""
"To lock the lock, a thread calls its :meth:`~RLock.acquire` method; this "
"returns once the thread owns the lock.  To unlock the lock, a thread calls "
"its :meth:`~Lock.release` method. :meth:`~Lock.acquire`/:meth:`~Lock."
"release` call pairs may be nested; only the final :meth:`~Lock.release` "
"(the :meth:`~Lock.release` of the outermost pair) resets the lock to "
"unlocked and allows another thread blocked in :meth:`~Lock.acquire` to "
"proceed."
msgstr ""

#: ../Doc/library/threading.rst:438
msgid ""
"Reentrant locks also support the :ref:`context management protocol <with-"
"locks>`."
msgstr ""

#: ../Doc/library/threading.rst:443
msgid ""
"This class implements reentrant lock objects.  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:448
msgid ""
"Note that ``RLock`` is actually a factory function which returns an instance "
"of the most efficient version of the concrete RLock class that is supported "
"by the platform."
msgstr ""

#: ../Doc/library/threading.rst:457
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:465
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:468
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:472
msgid ""
"When invoked with the floating-point *timeout* argument set to a positive "
"value, block for at most the number of seconds specified by *timeout* and as "
"long as the lock cannot be acquired.  Return true if the lock has been "
"acquired, false if the timeout has elapsed."
msgstr ""

#: ../Doc/library/threading.rst:483
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:489
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:499
msgid "Condition Objects"
msgstr ""

#: ../Doc/library/threading.rst:501
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.  The lock is part "
"of the condition object: you don't have to track it separately."
msgstr ""

#: ../Doc/library/threading.rst:506
msgid ""
"A condition variable obeys the :ref:`context management protocol <with-"
"locks>`: using the ``with`` statement acquires the associated lock for the "
"duration of the enclosed block.  The :meth:`~Condition.acquire` and :meth:"
"`~Condition.release` methods also call the corresponding methods of the "
"associated lock."
msgstr ""

#: ../Doc/library/threading.rst:512
msgid ""
"Other methods must be called with the associated lock held.  The :meth:"
"`~Condition.wait` method releases the lock, and then blocks until another "
"thread awakens it by calling :meth:`~Condition.notify` or :meth:`~Condition."
"notify_all`.  Once awakened, :meth:`~Condition.wait` re-acquires the lock "
"and returns.  It is also possible to specify a timeout."
msgstr ""

#: ../Doc/library/threading.rst:518
msgid ""
"The :meth:`~Condition.notify` method wakes up one of the threads waiting for "
"the condition variable, if any are waiting.  The :meth:`~Condition."
"notify_all` method wakes up all threads waiting for the condition variable."
msgstr ""

#: ../Doc/library/threading.rst:522
msgid ""
"Note: the :meth:`~Condition.notify` and :meth:`~Condition.notify_all` "
"methods don't release the lock; this means that the thread or threads "
"awakened will not return from their :meth:`~Condition.wait` call "
"immediately, but only when the thread that called :meth:`~Condition.notify` "
"or :meth:`~Condition.notify_all` finally relinquishes ownership of the lock."
msgstr ""

#: ../Doc/library/threading.rst:528
msgid ""
"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:`~Condition.wait` repeatedly until "
"they see the desired state, while threads that modify the state call :meth:"
"`~Condition.notify` or :meth:`~Condition.notify_all` 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:548
msgid ""
"The ``while`` loop checking for the application's condition is necessary "
"because :meth:`~Condition.wait` can return after an arbitrary long time, and "
"the condition which prompted the :meth:`~Condition.notify` call may no "
"longer hold true.  This is inherent to multi-threaded programming.  The :"
"meth:`~Condition.wait_for` method can be used to automate the condition "
"checking, and eases the computation of timeouts::"
msgstr ""

#: ../Doc/library/threading.rst:560
msgid ""
"To choose between :meth:`~Condition.notify` and :meth:`~Condition."
"notify_all`, 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:568
msgid ""
"This class implements condition variable objects.  A condition variable "
"allows one or more threads to wait until they are notified by another thread."
msgstr ""

#: ../Doc/library/threading.rst:571
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:575 ../Doc/library/threading.rst:697
#: ../Doc/library/threading.rst:740 ../Doc/library/threading.rst:792
#: ../Doc/library/threading.rst:861
msgid "changed from a factory function to a class."
msgstr ""

#: ../Doc/library/threading.rst:580
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:585
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:590
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:594
msgid ""
"This method releases the underlying lock, and then blocks until it is "
"awakened by a :meth:`notify` or :meth:`notify_all` 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:599
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:603
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:611
msgid ""
"The return value is ``True`` unless a given *timeout* expired, in which case "
"it is ``False``."
msgstr ""

#: ../Doc/library/threading.rst:614 ../Doc/library/threading.rst:826
msgid "Previously, the method always returned ``None``."
msgstr ""

#: ../Doc/library/threading.rst:619
msgid ""
"Wait until a condition evaluates to true.  *predicate* should be a callable "
"which result will be interpreted as a boolean value. A *timeout* may be "
"provided giving the maximum time to wait."
msgstr ""

#: ../Doc/library/threading.rst:623
msgid ""
"This utility method may call :meth:`wait` repeatedly until the predicate is "
"satisfied, or until a timeout occurs. The return value is the last return "
"value of the predicate and will evaluate to ``False`` if the method timed "
"out."
msgstr ""

#: ../Doc/library/threading.rst:628
msgid ""
"Ignoring the timeout feature, calling this method is roughly equivalent to "
"writing::"
msgstr ""

#: ../Doc/library/threading.rst:634
msgid ""
"Therefore, the same rules apply as with :meth:`wait`: The lock must be held "
"when called and is re-acquired on return.  The predicate is evaluated with "
"the lock held."
msgstr ""

#: ../Doc/library/threading.rst:642
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:646
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:649
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:654
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:660
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:669
msgid "Semaphore Objects"
msgstr ""

#: ../Doc/library/threading.rst:671
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 the names ``P()`` and ``V()`` instead of :meth:`~Semaphore."
"acquire` and :meth:`~Semaphore.release`)."
msgstr ""

#: ../Doc/library/threading.rst:676
msgid ""
"A semaphore manages an internal counter which is decremented by each :meth:"
"`~Semaphore.acquire` call and incremented by each :meth:`~Semaphore.release` "
"call.  The counter can never go below zero; when :meth:`~Semaphore.acquire` "
"finds that it is zero, it blocks, waiting until some other thread calls :"
"meth:`~Semaphore.release`."
msgstr ""

#: ../Doc/library/threading.rst:682
msgid ""
"Semaphores also support the :ref:`context management protocol <with-locks>`."
msgstr ""

#: ../Doc/library/threading.rst:687
msgid ""
"This class implements semaphore objects.  A semaphore manages an atomic "
"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:693
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:702
msgid "Acquire a semaphore."
msgstr ""

#: ../Doc/library/threading.rst:704
msgid "When invoked without arguments:"
msgstr ""

#: ../Doc/library/threading.rst:706
msgid ""
"If the internal counter is larger than zero on entry, decrement it by one "
"and return true immediately."
msgstr ""

#: ../Doc/library/threading.rst:708
msgid ""
"If the internal counter is zero on entry, block until awoken by a call to :"
"meth:`~Semaphore.release`.  Once awoken (and the counter is greater than 0), "
"decrement the counter by 1 and return true.  Exactly one thread will be "
"awoken by each call to :meth:`~Semaphore.release`.  The order in which "
"threads are awoken should not be relied on."
msgstr ""

#: ../Doc/library/threading.rst:714
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:718
msgid ""
"When invoked with a *timeout* other than ``None``, it will block for at most "
"*timeout* seconds.  If acquire does not complete successfully in that "
"interval, return false.  Return true otherwise."
msgstr ""

#: ../Doc/library/threading.rst:727
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:734
msgid ""
"Class implementing bounded semaphore objects.  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:747
msgid ":class:`Semaphore` Example"
msgstr ""

#: ../Doc/library/threading.rst:749
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:758
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:768
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:775
msgid "Event Objects"
msgstr ""

#: ../Doc/library/threading.rst:777
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:780
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:787
msgid ""
"Class implementing event objects.  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. The "
"flag is initially false."
msgstr ""

#: ../Doc/library/threading.rst:797
msgid "Return true if and only if the internal flag is true."
msgstr ""

#: ../Doc/library/threading.rst:801
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:807
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:813
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:817
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:821
msgid ""
"This method returns true if and only if the internal flag has been set to "
"true, either before the wait call or after the wait starts, so it will "
"always return ``True`` except if a timeout is given and the operation times "
"out."
msgstr ""

#: ../Doc/library/threading.rst:833
msgid "Timer Objects"
msgstr ""

#: ../Doc/library/threading.rst:835
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:839
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:845
msgid "For example::"
msgstr "Par exemple : ::"

#: ../Doc/library/threading.rst:856
msgid ""
"Create a timer that will run *function* with arguments *args* and  keyword "
"arguments *kwargs*, after *interval* seconds have passed. If *args* is "
"``None`` (the default) then an empty list will be used. If *kwargs* is "
"``None`` (the default) then an empty dict will be used."
msgstr ""

#: ../Doc/library/threading.rst:866
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:871
msgid "Barrier Objects"
msgstr ""

#: ../Doc/library/threading.rst:875
msgid ""
"This class provides a simple synchronization primitive for use by a fixed "
"number of threads that need to wait for each other.  Each of the threads "
"tries to pass the barrier by calling the :meth:`~Barrier.wait` method and "
"will block until all of the threads have made their :meth:`~Barrier.wait` "
"calls. At this point, the threads are released simultaneously."
msgstr ""

#: ../Doc/library/threading.rst:881
msgid ""
"The barrier can be reused any number of times for the same number of threads."
msgstr ""

#: ../Doc/library/threading.rst:883
msgid ""
"As an example, here is a simple way to synchronize a client and server "
"thread::"
msgstr ""

#: ../Doc/library/threading.rst:903
msgid ""
"Create a barrier object for *parties* number of threads.  An *action*, when "
"provided, is a callable to be called by one of the threads when they are "
"released.  *timeout* is the default timeout value if none is specified for "
"the :meth:`wait` method."
msgstr ""

#: ../Doc/library/threading.rst:910
msgid ""
"Pass the barrier.  When all the threads party to the barrier have called "
"this function, they are all released simultaneously.  If a *timeout* is "
"provided, it is used in preference to any that was supplied to the class "
"constructor."
msgstr ""

#: ../Doc/library/threading.rst:915
msgid ""
"The return value is an integer in the range 0 to *parties* -- 1, different "
"for each thread.  This can be used to select a thread to do some special "
"housekeeping, e.g.::"
msgstr ""

#: ../Doc/library/threading.rst:924
msgid ""
"If an *action* was provided to the constructor, one of the threads will have "
"called it prior to being released.  Should this call raise an error, the "
"barrier is put into the broken state."
msgstr ""

#: ../Doc/library/threading.rst:928
msgid "If the call times out, the barrier is put into the broken state."
msgstr ""

#: ../Doc/library/threading.rst:930
msgid ""
"This method may raise a :class:`BrokenBarrierError` exception if the barrier "
"is broken or reset while a thread is waiting."
msgstr ""

#: ../Doc/library/threading.rst:935
msgid ""
"Return the barrier to the default, empty state.  Any threads waiting on it "
"will receive the :class:`BrokenBarrierError` exception."
msgstr ""

#: ../Doc/library/threading.rst:938
msgid ""
"Note that using this function may can require some external synchronization "
"if there are other threads whose state is unknown.  If a barrier is broken "
"it may be better to just leave it and create a new one."
msgstr ""

#: ../Doc/library/threading.rst:944
msgid ""
"Put the barrier into a broken state.  This causes any active or future calls "
"to :meth:`wait` to fail with the :class:`BrokenBarrierError`.  Use this for "
"example if one of the needs to abort, to avoid deadlocking the application."
msgstr ""

#: ../Doc/library/threading.rst:949
msgid ""
"It may be preferable to simply create the barrier with a sensible *timeout* "
"value to automatically guard against one of the threads going awry."
msgstr ""

#: ../Doc/library/threading.rst:955
msgid "The number of threads required to pass the barrier."
msgstr ""

#: ../Doc/library/threading.rst:959
msgid "The number of threads currently waiting in the barrier."
msgstr ""

#: ../Doc/library/threading.rst:963
msgid "A boolean that is ``True`` if the barrier is in the broken state."
msgstr ""

#: ../Doc/library/threading.rst:968
msgid ""
"This exception, a subclass of :exc:`RuntimeError`, is raised when the :class:"
"`Barrier` object is reset or broken."
msgstr ""

#: ../Doc/library/threading.rst:975
msgid ""
"Using locks, conditions, and semaphores in the :keyword:`with` statement"
msgstr ""

#: ../Doc/library/threading.rst:977
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.  "
"Hence, the following snippet::"
msgstr ""

#: ../Doc/library/threading.rst:986
msgid "is equivalent to::"
msgstr ""

#: ../Doc/library/threading.rst:994
msgid ""
"Currently, :class:`Lock`, :class:`RLock`, :class:`Condition`, :class:"
"`Semaphore`, and :class:`BoundedSemaphore` objects may be used as :keyword:"
"`with` statement context managers."
msgstr ""
