# Copyright (C) 2001-2016, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-06-28 15:29+0200\n" "PO-Revision-Date: 2017-08-10 00:56+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 1.8.11\n" #: ../Doc/library/multiprocessing.rst:2 msgid ":mod:`multiprocessing` --- Process-based parallelism" msgstr "" #: ../Doc/library/multiprocessing.rst:7 msgid "**Source code:** :source:`Lib/multiprocessing/`" msgstr "" #: ../Doc/library/multiprocessing.rst:12 msgid "Introduction" msgstr "Introduction" #: ../Doc/library/multiprocessing.rst:14 msgid "" ":mod:`multiprocessing` is a package that supports spawning processes using " "an API similar to the :mod:`threading` module. The :mod:`multiprocessing` " "package offers both local and remote concurrency, effectively side-stepping " "the :term:`Global Interpreter Lock` by using subprocesses instead of " "threads. Due to this, the :mod:`multiprocessing` module allows the " "programmer to fully leverage multiple processors on a given machine. It " "runs on both Unix and Windows." msgstr "" #: ../Doc/library/multiprocessing.rst:22 msgid "" "The :mod:`multiprocessing` module also introduces APIs which do not have " "analogs in the :mod:`threading` module. A prime example of this is the :" "class:`~multiprocessing.pool.Pool` object which offers a convenient means of " "parallelizing the execution of a function across multiple input values, " "distributing the input data across processes (data parallelism). The " "following example demonstrates the common practice of defining such " "functions in a module so that child processes can successfully import that " "module. This basic example of data parallelism using :class:" "`~multiprocessing.pool.Pool`, ::" msgstr "" #: ../Doc/library/multiprocessing.rst:40 msgid "will print to standard output ::" msgstr "" #: ../Doc/library/multiprocessing.rst:46 msgid "The :class:`Process` class" msgstr "" #: ../Doc/library/multiprocessing.rst:48 msgid "" "In :mod:`multiprocessing`, processes are spawned by creating a :class:" "`Process` object and then calling its :meth:`~Process.start` method. :class:" "`Process` follows the API of :class:`threading.Thread`. A trivial example " "of a multiprocess program is ::" msgstr "" #: ../Doc/library/multiprocessing.rst:63 msgid "" "To show the individual process IDs involved, here is an expanded example::" msgstr "" #: ../Doc/library/multiprocessing.rst:84 msgid "" "For an explanation of why the ``if __name__ == '__main__'`` part is " "necessary, see :ref:`multiprocessing-programming`." msgstr "" #: ../Doc/library/multiprocessing.rst:90 msgid "Contexts and start methods" msgstr "" #: ../Doc/library/multiprocessing.rst:94 msgid "" "Depending on the platform, :mod:`multiprocessing` supports three ways to " "start a process. These *start methods* are" msgstr "" #: ../Doc/library/multiprocessing.rst:105 msgid "*spawn*" msgstr "*spawn*" #: ../Doc/library/multiprocessing.rst:98 msgid "" "The parent process starts a fresh python interpreter process. The child " "process will only inherit those resources necessary to run the process " "objects :meth:`~Process.run` method. In particular, unnecessary file " "descriptors and handles from the parent process will not be inherited. " "Starting a process using this method is rather slow compared to using *fork* " "or *forkserver*." msgstr "" #: ../Doc/library/multiprocessing.rst:105 msgid "Available on Unix and Windows. The default on Windows." msgstr "" #: ../Doc/library/multiprocessing.rst:114 msgid "*fork*" msgstr "*fork*" #: ../Doc/library/multiprocessing.rst:108 msgid "" "The parent process uses :func:`os.fork` to fork the Python interpreter. The " "child process, when it begins, is effectively identical to the parent " "process. All resources of the parent are inherited by the child process. " "Note that safely forking a multithreaded process is problematic." msgstr "" #: ../Doc/library/multiprocessing.rst:114 msgid "Available on Unix only. The default on Unix." msgstr "" #: ../Doc/library/multiprocessing.rst:125 msgid "*forkserver*" msgstr "" #: ../Doc/library/multiprocessing.rst:117 msgid "" "When the program starts and selects the *forkserver* start method, a server " "process is started. From then on, whenever a new process is needed, the " "parent process connects to the server and requests that it fork a new " "process. The fork server process is single threaded so it is safe for it to " "use :func:`os.fork`. No unnecessary resources are inherited." msgstr "" #: ../Doc/library/multiprocessing.rst:124 msgid "" "Available on Unix platforms which support passing file descriptors over Unix " "pipes." msgstr "" #: ../Doc/library/multiprocessing.rst:127 msgid "" "*spawn* added on all unix platforms, and *forkserver* added for some unix " "platforms. Child processes no longer inherit all of the parents inheritable " "handles on Windows." msgstr "" #: ../Doc/library/multiprocessing.rst:133 msgid "" "On Unix using the *spawn* or *forkserver* start methods will also start a " "*semaphore tracker* process which tracks the unlinked named semaphores " "created by processes of the program. When all processes have exited the " "semaphore tracker unlinks any remaining semaphores. Usually there should be " "none, but if a process was killed by a signal there may be some \"leaked\" " "semaphores. (Unlinking the named semaphores is a serious matter since the " "system allows only a limited number, and they will not be automatically " "unlinked until the next reboot.)" msgstr "" #: ../Doc/library/multiprocessing.rst:142 msgid "" "To select a start method you use the :func:`set_start_method` in the ``if " "__name__ == '__main__'`` clause of the main module. For example::" msgstr "" #: ../Doc/library/multiprocessing.rst:159 msgid "" ":func:`set_start_method` should not be used more than once in the program." msgstr "" #: ../Doc/library/multiprocessing.rst:162 msgid "" "Alternatively, you can use :func:`get_context` to obtain a context object. " "Context objects have the same API as the multiprocessing module, and allow " "one to use multiple start methods in the same program. ::" msgstr "" #: ../Doc/library/multiprocessing.rst:180 msgid "" "Note that objects related to one context may not be compatible with " "processes for a different context. In particular, locks created using the " "*fork* context cannot be passed to processes started using the *spawn* or " "*forkserver* start methods." msgstr "" #: ../Doc/library/multiprocessing.rst:185 msgid "" "A library which wants to use a particular start method should probably use :" "func:`get_context` to avoid interfering with the choice of the library user." msgstr "" #: ../Doc/library/multiprocessing.rst:191 msgid "Exchanging objects between processes" msgstr "" #: ../Doc/library/multiprocessing.rst:193 msgid "" ":mod:`multiprocessing` supports two types of communication channel between " "processes:" msgstr "" #: ../Doc/library/multiprocessing.rst:196 msgid "**Queues**" msgstr "**Queues**" #: ../Doc/library/multiprocessing.rst:198 msgid "" "The :class:`Queue` class is a near clone of :class:`queue.Queue`. For " "example::" msgstr "" #: ../Doc/library/multiprocessing.rst:213 msgid "Queues are thread and process safe." msgstr "" #: ../Doc/library/multiprocessing.rst:215 msgid "**Pipes**" msgstr "**Pipes**" #: ../Doc/library/multiprocessing.rst:217 msgid "" "The :func:`Pipe` function returns a pair of connection objects connected by " "a pipe which by default is duplex (two-way). For example::" msgstr "" #: ../Doc/library/multiprocessing.rst:233 msgid "" "The two connection objects returned by :func:`Pipe` represent the two ends " "of the pipe. Each connection object has :meth:`~Connection.send` and :meth:" "`~Connection.recv` methods (among others). Note that data in a pipe may " "become corrupted if two processes (or threads) try to read from or write to " "the *same* end of the pipe at the same time. Of course there is no risk of " "corruption from processes using different ends of the pipe at the same time." msgstr "" #: ../Doc/library/multiprocessing.rst:243 msgid "Synchronization between processes" msgstr "" #: ../Doc/library/multiprocessing.rst:245 msgid "" ":mod:`multiprocessing` contains equivalents of all the synchronization " "primitives from :mod:`threading`. For instance one can use a lock to ensure " "that only one process prints to standard output at a time::" msgstr "" #: ../Doc/library/multiprocessing.rst:264 msgid "" "Without using the lock output from the different processes is liable to get " "all mixed up." msgstr "" #: ../Doc/library/multiprocessing.rst:269 msgid "Sharing state between processes" msgstr "" #: ../Doc/library/multiprocessing.rst:271 msgid "" "As mentioned above, when doing concurrent programming it is usually best to " "avoid using shared state as far as possible. This is particularly true when " "using multiple processes." msgstr "" #: ../Doc/library/multiprocessing.rst:275 msgid "" "However, if you really do need to use some shared data then :mod:" "`multiprocessing` provides a couple of ways of doing so." msgstr "" #: ../Doc/library/multiprocessing.rst:278 msgid "**Shared memory**" msgstr "" #: ../Doc/library/multiprocessing.rst:280 msgid "" "Data can be stored in a shared memory map using :class:`Value` or :class:" "`Array`. For example, the following code ::" msgstr "" #: ../Doc/library/multiprocessing.rst:301 #: ../Doc/library/multiprocessing.rst:347 msgid "will print ::" msgstr "" #: ../Doc/library/multiprocessing.rst:306 msgid "" "The ``'d'`` and ``'i'`` arguments used when creating ``num`` and ``arr`` are " "typecodes of the kind used by the :mod:`array` module: ``'d'`` indicates a " "double precision float and ``'i'`` indicates a signed integer. These shared " "objects will be process and thread-safe." msgstr "" #: ../Doc/library/multiprocessing.rst:311 msgid "" "For more flexibility in using shared memory one can use the :mod:" "`multiprocessing.sharedctypes` module which supports the creation of " "arbitrary ctypes objects allocated from shared memory." msgstr "" #: ../Doc/library/multiprocessing.rst:315 msgid "**Server process**" msgstr "" #: ../Doc/library/multiprocessing.rst:317 msgid "" "A manager object returned by :func:`Manager` controls a server process which " "holds Python objects and allows other processes to manipulate them using " "proxies." msgstr "" #: ../Doc/library/multiprocessing.rst:321 msgid "" "A manager returned by :func:`Manager` will support types :class:`list`, :" "class:`dict`, :class:`~managers.Namespace`, :class:`Lock`, :class:`RLock`, :" "class:`Semaphore`, :class:`BoundedSemaphore`, :class:`Condition`, :class:" "`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` and :class:" "`Array`. For example, ::" msgstr "" #: ../Doc/library/multiprocessing.rst:352 msgid "" "Server process managers are more flexible than using shared memory objects " "because they can be made to support arbitrary object types. Also, a single " "manager can be shared by processes on different computers over a network. " "They are, however, slower than using shared memory." msgstr "" #: ../Doc/library/multiprocessing.rst:359 msgid "Using a pool of workers" msgstr "" #: ../Doc/library/multiprocessing.rst:361 msgid "" "The :class:`~multiprocessing.pool.Pool` class represents a pool of worker " "processes. It has methods which allows tasks to be offloaded to the worker " "processes in a few different ways." msgstr "" #: ../Doc/library/multiprocessing.rst:365 msgid "For example::" msgstr "Par exemple ::" #: ../Doc/library/multiprocessing.rst:409 msgid "" "Note that the methods of a pool should only ever be used by the process " "which created it." msgstr "" #: ../Doc/library/multiprocessing.rst:414 msgid "" "Functionality within this package requires that the ``__main__`` module be " "importable by the children. This is covered in :ref:`multiprocessing-" "programming` however it is worth pointing out here. This means that some " "examples, such as the :class:`multiprocessing.pool.Pool` examples will not " "work in the interactive interpreter. For example::" msgstr "" #: ../Doc/library/multiprocessing.rst:436 msgid "" "(If you try this it will actually output three full tracebacks interleaved " "in a semi-random fashion, and then you may have to stop the master process " "somehow.)" msgstr "" #: ../Doc/library/multiprocessing.rst:442 msgid "Reference" msgstr "" #: ../Doc/library/multiprocessing.rst:444 msgid "" "The :mod:`multiprocessing` package mostly replicates the API of the :mod:" "`threading` module." msgstr "" #: ../Doc/library/multiprocessing.rst:449 msgid ":class:`Process` and exceptions" msgstr "" #: ../Doc/library/multiprocessing.rst:454 msgid "" "Process objects represent activity that is run in a separate process. The :" "class:`Process` class has equivalents of all the methods of :class:" "`threading.Thread`." msgstr "" #: ../Doc/library/multiprocessing.rst:458 msgid "" "The constructor should always be called with keyword arguments. *group* " "should always be ``None``; it exists solely for compatibility with :class:" "`threading.Thread`. *target* is the callable object to be invoked by the :" "meth:`run()` method. It defaults to ``None``, meaning nothing is called. " "*name* is the process name (see :attr:`name` for more details). *args* is " "the argument tuple for the target invocation. *kwargs* is a dictionary of " "keyword arguments for the target invocation. If provided, the keyword-only " "*daemon* argument sets the process :attr:`daemon` flag to ``True`` or " "``False``. If ``None`` (the default), this flag will be inherited from the " "creating process." msgstr "" #: ../Doc/library/multiprocessing.rst:469 msgid "By default, no arguments are passed to *target*." msgstr "" #: ../Doc/library/multiprocessing.rst:471 msgid "" "If a subclass overrides the constructor, it must make sure it invokes the " "base class constructor (:meth:`Process.__init__`) before doing anything else " "to the process." msgstr "" #: ../Doc/library/multiprocessing.rst:475 msgid "Added the *daemon* argument." msgstr "" #: ../Doc/library/multiprocessing.rst:480 msgid "Method representing the process's activity." msgstr "" #: ../Doc/library/multiprocessing.rst:482 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/multiprocessing.rst:489 msgid "Start the process's activity." msgstr "" #: ../Doc/library/multiprocessing.rst:491 msgid "" "This must be called at most once per process object. It arranges for the " "object's :meth:`run` method to be invoked in a separate process." msgstr "" #: ../Doc/library/multiprocessing.rst:496 msgid "" "If the optional argument *timeout* is ``None`` (the default), the method " "blocks until the process whose :meth:`join` method is called terminates. If " "*timeout* is a positive number, it blocks at most *timeout* seconds. Note " "that the method returns ``None`` if its process terminates or if the method " "times out. Check the process's :attr:`exitcode` to determine if it " "terminated." msgstr "" #: ../Doc/library/multiprocessing.rst:503 msgid "A process can be joined many times." msgstr "" #: ../Doc/library/multiprocessing.rst:505 msgid "" "A process cannot join itself because this would cause a deadlock. It is an " "error to attempt to join a process before it has been started." msgstr "" #: ../Doc/library/multiprocessing.rst:510 msgid "" "The process's name. The name is a string used for identification purposes " "only. It has no semantics. Multiple processes may be given the same name." msgstr "" #: ../Doc/library/multiprocessing.rst:514 msgid "" "The initial name is set by the constructor. If no explicit name is provided " "to the constructor, a name of the form 'Process-N\\ :sub:`1`:N\\ :sub:" "`2`:...:N\\ :sub:`k`' is constructed, where each N\\ :sub:`k` is the N-th " "child of its parent." msgstr "" #: ../Doc/library/multiprocessing.rst:521 msgid "Return whether the process is alive." msgstr "" #: ../Doc/library/multiprocessing.rst:523 msgid "" "Roughly, a process object is alive from the moment the :meth:`start` method " "returns until the child process terminates." msgstr "" #: ../Doc/library/multiprocessing.rst:528 msgid "" "The process's daemon flag, a Boolean value. This must be set before :meth:" "`start` is called." msgstr "" #: ../Doc/library/multiprocessing.rst:531 msgid "The initial value is inherited from the creating process." msgstr "" #: ../Doc/library/multiprocessing.rst:533 msgid "" "When a process exits, it attempts to terminate all of its daemonic child " "processes." msgstr "" #: ../Doc/library/multiprocessing.rst:536 msgid "" "Note that a daemonic process is not allowed to create child processes. " "Otherwise a daemonic process would leave its children orphaned if it gets " "terminated when its parent process exits. Additionally, these are **not** " "Unix daemons or services, they are normal processes that will be terminated " "(and not joined) if non-daemonic processes have exited." msgstr "" #: ../Doc/library/multiprocessing.rst:542 msgid "" "In addition to the :class:`threading.Thread` API, :class:`Process` objects " "also support the following attributes and methods:" msgstr "" #: ../Doc/library/multiprocessing.rst:547 msgid "" "Return the process ID. Before the process is spawned, this will be ``None``." msgstr "" #: ../Doc/library/multiprocessing.rst:552 msgid "" "The child's exit code. This will be ``None`` if the process has not yet " "terminated. A negative value *-N* indicates that the child was terminated " "by signal *N*." msgstr "" #: ../Doc/library/multiprocessing.rst:558 msgid "The process's authentication key (a byte string)." msgstr "" #: ../Doc/library/multiprocessing.rst:560 msgid "" "When :mod:`multiprocessing` is initialized the main process is assigned a " "random string using :func:`os.urandom`." msgstr "" #: ../Doc/library/multiprocessing.rst:563 msgid "" "When a :class:`Process` object is created, it will inherit the " "authentication key of its parent process, although this may be changed by " "setting :attr:`authkey` to another byte string." msgstr "" #: ../Doc/library/multiprocessing.rst:567 msgid "See :ref:`multiprocessing-auth-keys`." msgstr "" #: ../Doc/library/multiprocessing.rst:571 msgid "" "A numeric handle of a system object which will become \"ready\" when the " "process ends." msgstr "" #: ../Doc/library/multiprocessing.rst:574 msgid "" "You can use this value if you want to wait on several events at once using :" "func:`multiprocessing.connection.wait`. Otherwise calling :meth:`join()` is " "simpler." msgstr "" #: ../Doc/library/multiprocessing.rst:578 msgid "" "On Windows, this is an OS handle usable with the ``WaitForSingleObject`` and " "``WaitForMultipleObjects`` family of API calls. On Unix, this is a file " "descriptor usable with primitives from the :mod:`select` module." msgstr "" #: ../Doc/library/multiprocessing.rst:586 msgid "" "Terminate the process. On Unix this is done using the ``SIGTERM`` signal; " "on Windows :c:func:`TerminateProcess` is used. Note that exit handlers and " "finally clauses, etc., will not be executed." msgstr "" #: ../Doc/library/multiprocessing.rst:590 msgid "" "Note that descendant processes of the process will *not* be terminated -- " "they will simply become orphaned." msgstr "" #: ../Doc/library/multiprocessing.rst:595 msgid "" "If this method is used when the associated process is using a pipe or queue " "then the pipe or queue is liable to become corrupted and may become unusable " "by other process. Similarly, if the process has acquired a lock or " "semaphore etc. then terminating it is liable to cause other processes to " "deadlock." msgstr "" #: ../Doc/library/multiprocessing.rst:603 msgid "Same as :meth:`terminate()` but using the ``SIGKILL`` signal on Unix." msgstr "" #: ../Doc/library/multiprocessing.rst:609 msgid "" "Close the :class:`Process` object, releasing all resources associated with " "it. :exc:`ValueError` is raised if the underlying process is still " "running. Once :meth:`close` returns successfully, most other methods and " "attributes of the :class:`Process` object will raise :exc:`ValueError`." msgstr "" #: ../Doc/library/multiprocessing.rst:617 msgid "" "Note that the :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:" "`terminate` and :attr:`exitcode` methods should only be called by the " "process that created the process object." msgstr "" #: ../Doc/library/multiprocessing.rst:621 msgid "Example usage of some of the methods of :class:`Process`:" msgstr "" #: ../Doc/library/multiprocessing.rst:641 msgid "The base class of all :mod:`multiprocessing` exceptions." msgstr "" #: ../Doc/library/multiprocessing.rst:645 msgid "" "Exception raised by :meth:`Connection.recv_bytes_into()` when the supplied " "buffer object is too small for the message read." msgstr "" #: ../Doc/library/multiprocessing.rst:648 msgid "" "If ``e`` is an instance of :exc:`BufferTooShort` then ``e.args[0]`` will " "give the message as a byte string." msgstr "" #: ../Doc/library/multiprocessing.rst:653 msgid "Raised when there is an authentication error." msgstr "" #: ../Doc/library/multiprocessing.rst:657 msgid "Raised by methods with a timeout when the timeout expires." msgstr "" #: ../Doc/library/multiprocessing.rst:660 msgid "Pipes and Queues" msgstr "" #: ../Doc/library/multiprocessing.rst:662 msgid "" "When using multiple processes, one generally uses message passing for " "communication between processes and avoids having to use any synchronization " "primitives like locks." msgstr "" #: ../Doc/library/multiprocessing.rst:666 msgid "" "For passing messages one can use :func:`Pipe` (for a connection between two " "processes) or a queue (which allows multiple producers and consumers)." msgstr "" #: ../Doc/library/multiprocessing.rst:669 msgid "" "The :class:`Queue`, :class:`SimpleQueue` and :class:`JoinableQueue` types " "are multi-producer, multi-consumer :abbr:`FIFO (first-in, first-out)` queues " "modelled on the :class:`queue.Queue` class in the standard library. They " "differ in that :class:`Queue` lacks the :meth:`~queue.Queue.task_done` and :" "meth:`~queue.Queue.join` methods introduced into Python 2.5's :class:`queue." "Queue` class." msgstr "" #: ../Doc/library/multiprocessing.rst:676 msgid "" "If you use :class:`JoinableQueue` then you **must** call :meth:" "`JoinableQueue.task_done` for each task removed from the queue or else the " "semaphore used to count the number of unfinished tasks may eventually " "overflow, raising an exception." msgstr "" #: ../Doc/library/multiprocessing.rst:681 msgid "" "Note that one can also create a shared queue by using a manager object -- " "see :ref:`multiprocessing-managers`." msgstr "" #: ../Doc/library/multiprocessing.rst:686 msgid "" ":mod:`multiprocessing` uses the usual :exc:`queue.Empty` and :exc:`queue." "Full` exceptions to signal a timeout. They are not available in the :mod:" "`multiprocessing` namespace so you need to import them from :mod:`queue`." msgstr "" #: ../Doc/library/multiprocessing.rst:693 msgid "" "When an object is put on a queue, the object is pickled and a background " "thread later flushes the pickled data to an underlying pipe. This has some " "consequences which are a little surprising, but should not cause any " "practical difficulties -- if they really bother you then you can instead use " "a queue created with a :ref:`manager `." msgstr "" #: ../Doc/library/multiprocessing.rst:700 msgid "" "After putting an object on an empty queue there may be an infinitesimal " "delay before the queue's :meth:`~Queue.empty` method returns :const:`False` " "and :meth:`~Queue.get_nowait` can return without raising :exc:`queue.Empty`." msgstr "" #: ../Doc/library/multiprocessing.rst:705 msgid "" "If multiple processes are enqueuing objects, it is possible for the objects " "to be received at the other end out-of-order. However, objects enqueued by " "the same process will always be in the expected order with respect to each " "other." msgstr "" #: ../Doc/library/multiprocessing.rst:712 msgid "" "If a process is killed using :meth:`Process.terminate` or :func:`os.kill` " "while it is trying to use a :class:`Queue`, then the data in the queue is " "likely to become corrupted. This may cause any other process to get an " "exception when it tries to use the queue later on." msgstr "" #: ../Doc/library/multiprocessing.rst:719 msgid "" "As mentioned above, if a child process has put items on a queue (and it has " "not used :meth:`JoinableQueue.cancel_join_thread `), then that process will not terminate until all " "buffered items have been flushed to the pipe." msgstr "" #: ../Doc/library/multiprocessing.rst:724 msgid "" "This means that if you try joining that process you may get a deadlock " "unless you are sure that all items which have been put on the queue have " "been consumed. Similarly, if the child process is non-daemonic then the " "parent process may hang on exit when it tries to join all its non-daemonic " "children." msgstr "" #: ../Doc/library/multiprocessing.rst:729 msgid "" "Note that a queue created using a manager does not have this issue. See :" "ref:`multiprocessing-programming`." msgstr "" #: ../Doc/library/multiprocessing.rst:732 msgid "" "For an example of the usage of queues for interprocess communication see :" "ref:`multiprocessing-examples`." msgstr "" #: ../Doc/library/multiprocessing.rst:738 msgid "" "Returns a pair ``(conn1, conn2)`` of :class:`~multiprocessing.connection." "Connection` objects representing the ends of a pipe." msgstr "" #: ../Doc/library/multiprocessing.rst:742 msgid "" "If *duplex* is ``True`` (the default) then the pipe is bidirectional. If " "*duplex* is ``False`` then the pipe is unidirectional: ``conn1`` can only be " "used for receiving messages and ``conn2`` can only be used for sending " "messages." msgstr "" #: ../Doc/library/multiprocessing.rst:750 msgid "" "Returns a process shared queue implemented using a pipe and a few locks/" "semaphores. When a process first puts an item on the queue a feeder thread " "is started which transfers objects from a buffer into the pipe." msgstr "" #: ../Doc/library/multiprocessing.rst:754 msgid "" "The usual :exc:`queue.Empty` and :exc:`queue.Full` exceptions from the " "standard library's :mod:`queue` module are raised to signal timeouts." msgstr "" #: ../Doc/library/multiprocessing.rst:757 msgid "" ":class:`Queue` implements all the methods of :class:`queue.Queue` except " "for :meth:`~queue.Queue.task_done` and :meth:`~queue.Queue.join`." msgstr "" #: ../Doc/library/multiprocessing.rst:762 msgid "" "Return the approximate size of the queue. Because of multithreading/" "multiprocessing semantics, this number is not reliable." msgstr "" #: ../Doc/library/multiprocessing.rst:765 msgid "" "Note that this may raise :exc:`NotImplementedError` on Unix platforms like " "Mac OS X where ``sem_getvalue()`` is not implemented." msgstr "" #: ../Doc/library/multiprocessing.rst:770 msgid "" "Return ``True`` if the queue is empty, ``False`` otherwise. Because of " "multithreading/multiprocessing semantics, this is not reliable." msgstr "" #: ../Doc/library/multiprocessing.rst:775 msgid "" "Return ``True`` if the queue is full, ``False`` otherwise. Because of " "multithreading/multiprocessing semantics, this is not reliable." msgstr "" #: ../Doc/library/multiprocessing.rst:780 msgid "" "Put obj into the queue. If the optional argument *block* is ``True`` (the " "default) and *timeout* is ``None`` (the default), block if necessary until a " "free slot is available. If *timeout* is a positive number, it blocks at " "most *timeout* seconds and raises the :exc:`queue.Full` exception if no free " "slot was available within that time. Otherwise (*block* is ``False``), put " "an item on the queue if a free slot is immediately available, else raise " "the :exc:`queue.Full` exception (*timeout* is ignored in that case)." msgstr "" #: ../Doc/library/multiprocessing.rst:791 msgid "Equivalent to ``put(obj, False)``." msgstr "" #: ../Doc/library/multiprocessing.rst:795 msgid "" "Remove and return an item from the queue. If optional args *block* is " "``True`` (the default) and *timeout* is ``None`` (the default), block if " "necessary until an item is available. If *timeout* is a positive number, it " "blocks at most *timeout* seconds and raises the :exc:`queue.Empty` exception " "if no item was available within that time. Otherwise (block is ``False``), " "return an item if one is immediately available, else raise the :exc:`queue." "Empty` exception (*timeout* is ignored in that case)." msgstr "" #: ../Doc/library/multiprocessing.rst:805 msgid "Equivalent to ``get(False)``." msgstr "" #: ../Doc/library/multiprocessing.rst:807 msgid "" ":class:`multiprocessing.Queue` has a few additional methods not found in :" "class:`queue.Queue`. These methods are usually unnecessary for most code:" msgstr "" #: ../Doc/library/multiprocessing.rst:813 msgid "" "Indicate that no more data will be put on this queue by the current " "process. The background thread will quit once it has flushed all buffered " "data to the pipe. This is called automatically when the queue is garbage " "collected." msgstr "" #: ../Doc/library/multiprocessing.rst:820 msgid "" "Join the background thread. This can only be used after :meth:`close` has " "been called. It blocks until the background thread exits, ensuring that all " "data in the buffer has been flushed to the pipe." msgstr "" #: ../Doc/library/multiprocessing.rst:824 msgid "" "By default if a process is not the creator of the queue then on exit it will " "attempt to join the queue's background thread. The process can call :meth:" "`cancel_join_thread` to make :meth:`join_thread` do nothing." msgstr "" #: ../Doc/library/multiprocessing.rst:830 msgid "" "Prevent :meth:`join_thread` from blocking. In particular, this prevents the " "background thread from being joined automatically when the process exits -- " "see :meth:`join_thread`." msgstr "" #: ../Doc/library/multiprocessing.rst:834 msgid "" "A better name for this method might be ``allow_exit_without_flush()``. It " "is likely to cause enqueued data to lost, and you almost certainly will not " "need to use it. It is really only there if you need the current process to " "exit immediately without waiting to flush enqueued data to the underlying " "pipe, and you don't care about lost data." msgstr "" #: ../Doc/library/multiprocessing.rst:843 msgid "" "This class's functionality requires a functioning shared semaphore " "implementation on the host operating system. Without one, the functionality " "in this class will be disabled, and attempts to instantiate a :class:`Queue` " "will result in an :exc:`ImportError`. See :issue:`3770` for additional " "information. The same holds true for any of the specialized queue types " "listed below." msgstr "" #: ../Doc/library/multiprocessing.rst:852 msgid "" "It is a simplified :class:`Queue` type, very close to a locked :class:`Pipe`." msgstr "" #: ../Doc/library/multiprocessing.rst:856 msgid "Return ``True`` if the queue is empty, ``False`` otherwise." msgstr "" #: ../Doc/library/multiprocessing.rst:860 msgid "Remove and return an item from the queue." msgstr "Supprime et donne un élément de la queue." #: ../Doc/library/multiprocessing.rst:864 msgid "Put *item* into the queue." msgstr "" #: ../Doc/library/multiprocessing.rst:869 msgid "" ":class:`JoinableQueue`, a :class:`Queue` subclass, is a queue which " "additionally has :meth:`task_done` and :meth:`join` methods." msgstr "" #: ../Doc/library/multiprocessing.rst:874 msgid "" "Indicate that a formerly enqueued task is complete. Used by queue " "consumers. For each :meth:`~Queue.get` used to fetch a task, a subsequent " "call to :meth:`task_done` tells the queue that the processing on the task is " "complete." msgstr "" #: ../Doc/library/multiprocessing.rst:879 msgid "" "If a :meth:`~queue.Queue.join` is currently blocking, it will resume when " "all items have been processed (meaning that a :meth:`task_done` call was " "received for every item that had been :meth:`~Queue.put` into the queue)." msgstr "" #: ../Doc/library/multiprocessing.rst:883 msgid "" "Raises a :exc:`ValueError` if called more times than there were items placed " "in the queue." msgstr "" #: ../Doc/library/multiprocessing.rst:889 msgid "Block until all items in the queue have been gotten and processed." msgstr "" #: ../Doc/library/multiprocessing.rst:891 msgid "" "The count of unfinished tasks goes up whenever an item is added to the " "queue. The count goes down whenever a consumer calls :meth:`task_done` to " "indicate that the item was retrieved and all work on it is complete. When " "the count of unfinished tasks drops to zero, :meth:`~queue.Queue.join` " "unblocks." msgstr "" #: ../Doc/library/multiprocessing.rst:899 msgid "Miscellaneous" msgstr "" #: ../Doc/library/multiprocessing.rst:903 msgid "Return list of all live children of the current process." msgstr "" #: ../Doc/library/multiprocessing.rst:905 msgid "" "Calling this has the side effect of \"joining\" any processes which have " "already finished." msgstr "" #: ../Doc/library/multiprocessing.rst:910 msgid "Return the number of CPUs in the system." msgstr "" #: ../Doc/library/multiprocessing.rst:912 msgid "" "This number is not equivalent to the number of CPUs the current process can " "use. The number of usable CPUs can be obtained with ``len(os." "sched_getaffinity(0))``" msgstr "" "Ce nombre n'est pas équivalent au nombre de CPUs que le processus courant " "peut utiliser. Le nombre de CPUs utilisables peut être obtenu avec ``len(os." "sched_getaffinity(0))``" #: ../Doc/library/multiprocessing.rst:916 msgid "May raise :exc:`NotImplementedError`." msgstr "" #: ../Doc/library/multiprocessing.rst:919 msgid ":func:`os.cpu_count`" msgstr "" #: ../Doc/library/multiprocessing.rst:923 msgid "" "Return the :class:`Process` object corresponding to the current process." msgstr "" #: ../Doc/library/multiprocessing.rst:925 msgid "An analogue of :func:`threading.current_thread`." msgstr "" #: ../Doc/library/multiprocessing.rst:929 msgid "" "Add support for when a program which uses :mod:`multiprocessing` has been " "frozen to produce a Windows executable. (Has been tested with **py2exe**, " "**PyInstaller** and **cx_Freeze**.)" msgstr "" #: ../Doc/library/multiprocessing.rst:933 msgid "" "One needs to call this function straight after the ``if __name__ == " "'__main__'`` line of the main module. For example::" msgstr "" #: ../Doc/library/multiprocessing.rst:945 msgid "" "If the ``freeze_support()`` line is omitted then trying to run the frozen " "executable will raise :exc:`RuntimeError`." msgstr "" #: ../Doc/library/multiprocessing.rst:948 msgid "" "Calling ``freeze_support()`` has no effect when invoked on any operating " "system other than Windows. In addition, if the module is being run normally " "by the Python interpreter on Windows (the program has not been frozen), then " "``freeze_support()`` has no effect." msgstr "" #: ../Doc/library/multiprocessing.rst:955 msgid "" "Returns a list of the supported start methods, the first of which is the " "default. The possible start methods are ``'fork'``, ``'spawn'`` and " "``'forkserver'``. On Windows only ``'spawn'`` is available. On Unix " "``'fork'`` and ``'spawn'`` are always supported, with ``'fork'`` being the " "default." msgstr "" #: ../Doc/library/multiprocessing.rst:965 msgid "" "Return a context object which has the same attributes as the :mod:" "`multiprocessing` module." msgstr "" #: ../Doc/library/multiprocessing.rst:968 msgid "" "If *method* is ``None`` then the default context is returned. Otherwise " "*method* should be ``'fork'``, ``'spawn'``, ``'forkserver'``. :exc:" "`ValueError` is raised if the specified start method is not available." msgstr "" #: ../Doc/library/multiprocessing.rst:977 msgid "Return the name of start method used for starting processes." msgstr "" #: ../Doc/library/multiprocessing.rst:979 msgid "" "If the start method has not been fixed and *allow_none* is false, then the " "start method is fixed to the default and the name is returned. If the start " "method has not been fixed and *allow_none* is true then ``None`` is returned." msgstr "" #: ../Doc/library/multiprocessing.rst:984 msgid "" "The return value can be ``'fork'``, ``'spawn'``, ``'forkserver'`` or " "``None``. ``'fork'`` is the default on Unix, while ``'spawn'`` is the " "default on Windows." msgstr "" #: ../Doc/library/multiprocessing.rst:992 msgid "" "Sets the path of the Python interpreter to use when starting a child " "process. (By default :data:`sys.executable` is used). Embedders will " "probably need to do some thing like ::" msgstr "" #: ../Doc/library/multiprocessing.rst:998 msgid "before they can create child processes." msgstr "" #: ../Doc/library/multiprocessing.rst:1000 msgid "Now supported on Unix when the ``'spawn'`` start method is used." msgstr "" #: ../Doc/library/multiprocessing.rst:1005 msgid "" "Set the method which should be used to start child processes. *method* can " "be ``'fork'``, ``'spawn'`` or ``'forkserver'``." msgstr "" #: ../Doc/library/multiprocessing.rst:1008 msgid "" "Note that this should be called at most once, and it should be protected " "inside the ``if __name__ == '__main__'`` clause of the main module." msgstr "" #: ../Doc/library/multiprocessing.rst:1016 msgid "" ":mod:`multiprocessing` contains no analogues of :func:`threading." "active_count`, :func:`threading.enumerate`, :func:`threading.settrace`, :" "func:`threading.setprofile`, :class:`threading.Timer`, or :class:`threading." "local`." msgstr "" #: ../Doc/library/multiprocessing.rst:1023 msgid "Connection Objects" msgstr "" #: ../Doc/library/multiprocessing.rst:1027 msgid "" "Connection objects allow the sending and receiving of picklable objects or " "strings. They can be thought of as message oriented connected sockets." msgstr "" #: ../Doc/library/multiprocessing.rst:1030 msgid "" "Connection objects are usually created using :func:`Pipe ` -- see also :ref:`multiprocessing-listeners-clients`." msgstr "" #: ../Doc/library/multiprocessing.rst:1038 msgid "" "Send an object to the other end of the connection which should be read " "using :meth:`recv`." msgstr "" #: ../Doc/library/multiprocessing.rst:1041 msgid "" "The object must be picklable. Very large pickles (approximately 32 MiB+, " "though it depends on the OS) may raise a :exc:`ValueError` exception." msgstr "" #: ../Doc/library/multiprocessing.rst:1046 msgid "" "Return an object sent from the other end of the connection using :meth:" "`send`. Blocks until there is something to receive. Raises :exc:`EOFError` " "if there is nothing left to receive and the other end was closed." msgstr "" #: ../Doc/library/multiprocessing.rst:1053 msgid "Return the file descriptor or handle used by the connection." msgstr "" #: ../Doc/library/multiprocessing.rst:1057 msgid "Close the connection." msgstr "" #: ../Doc/library/multiprocessing.rst:1059 msgid "This is called automatically when the connection is garbage collected." msgstr "" #: ../Doc/library/multiprocessing.rst:1063 msgid "Return whether there is any data available to be read." msgstr "" #: ../Doc/library/multiprocessing.rst:1065 msgid "" "If *timeout* is not specified then it will return immediately. If *timeout* " "is a number then this specifies the maximum time in seconds to block. If " "*timeout* is ``None`` then an infinite timeout is used." msgstr "" #: ../Doc/library/multiprocessing.rst:1069 msgid "" "Note that multiple connection objects may be polled at once by using :func:" "`multiprocessing.connection.wait`." msgstr "" #: ../Doc/library/multiprocessing.rst:1074 msgid "Send byte data from a :term:`bytes-like object` as a complete message." msgstr "" #: ../Doc/library/multiprocessing.rst:1076 msgid "" "If *offset* is given then data is read from that position in *buffer*. If " "*size* is given then that many bytes will be read from buffer. Very large " "buffers (approximately 32 MiB+, though it depends on the OS) may raise a :" "exc:`ValueError` exception" msgstr "" #: ../Doc/library/multiprocessing.rst:1083 msgid "" "Return a complete message of byte data sent from the other end of the " "connection as a string. Blocks until there is something to receive. Raises :" "exc:`EOFError` if there is nothing left to receive and the other end has " "closed." msgstr "" #: ../Doc/library/multiprocessing.rst:1088 msgid "" "If *maxlength* is specified and the message is longer than *maxlength* then :" "exc:`OSError` is raised and the connection will no longer be readable." msgstr "" #: ../Doc/library/multiprocessing.rst:1092 msgid "" "This function used to raise :exc:`IOError`, which is now an alias of :exc:" "`OSError`." msgstr "" #: ../Doc/library/multiprocessing.rst:1099 msgid "" "Read into *buffer* a complete message of byte data sent from the other end " "of the connection and return the number of bytes in the message. Blocks " "until there is something to receive. Raises :exc:`EOFError` if there is " "nothing left to receive and the other end was closed." msgstr "" #: ../Doc/library/multiprocessing.rst:1105 msgid "" "*buffer* must be a writable :term:`bytes-like object`. If *offset* is given " "then the message will be written into the buffer from that position. Offset " "must be a non-negative integer less than the length of *buffer* (in bytes)." msgstr "" #: ../Doc/library/multiprocessing.rst:1110 msgid "" "If the buffer is too short then a :exc:`BufferTooShort` exception is raised " "and the complete message is available as ``e.args[0]`` where ``e`` is the " "exception instance." msgstr "" #: ../Doc/library/multiprocessing.rst:1114 msgid "" "Connection objects themselves can now be transferred between processes " "using :meth:`Connection.send` and :meth:`Connection.recv`." msgstr "" #: ../Doc/library/multiprocessing.rst:1118 msgid "" "Connection objects now support the context management protocol -- see :ref:" "`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the " "connection object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." msgstr "" #: ../Doc/library/multiprocessing.rst:1123 msgid "For example:" msgstr "Par exemple ::" #: ../Doc/library/multiprocessing.rst:1147 msgid "" "The :meth:`Connection.recv` method automatically unpickles the data it " "receives, which can be a security risk unless you can trust the process " "which sent the message." msgstr "" #: ../Doc/library/multiprocessing.rst:1151 msgid "" "Therefore, unless the connection object was produced using :func:`Pipe` you " "should only use the :meth:`~Connection.recv` and :meth:`~Connection.send` " "methods after performing some sort of authentication. See :ref:" "`multiprocessing-auth-keys`." msgstr "" #: ../Doc/library/multiprocessing.rst:1158 msgid "" "If a process is killed while it is trying to read or write to a pipe then " "the data in the pipe is likely to become corrupted, because it may become " "impossible to be sure where the message boundaries lie." msgstr "" #: ../Doc/library/multiprocessing.rst:1164 msgid "Synchronization primitives" msgstr "" #: ../Doc/library/multiprocessing.rst:1168 msgid "" "Generally synchronization primitives are not as necessary in a multiprocess " "program as they are in a multithreaded program. See the documentation for :" "mod:`threading` module." msgstr "" #: ../Doc/library/multiprocessing.rst:1172 msgid "" "Note that one can also create synchronization primitives by using a manager " "object -- see :ref:`multiprocessing-managers`." msgstr "" #: ../Doc/library/multiprocessing.rst:1177 msgid "A barrier object: a clone of :class:`threading.Barrier`." msgstr "" #: ../Doc/library/multiprocessing.rst:1183 msgid "" "A bounded semaphore object: a close analog of :class:`threading." "BoundedSemaphore`." msgstr "" #: ../Doc/library/multiprocessing.rst:1186 #: ../Doc/library/multiprocessing.rst:1324 msgid "" "A solitary difference from its close analog exists: its ``acquire`` method's " "first argument is named *block*, as is consistent with :meth:`Lock.acquire`." msgstr "" #: ../Doc/library/multiprocessing.rst:1190 msgid "" "On Mac OS X, this is indistinguishable from :class:`Semaphore` because " "``sem_getvalue()`` is not implemented on that platform." msgstr "" #: ../Doc/library/multiprocessing.rst:1195 msgid "A condition variable: an alias for :class:`threading.Condition`." msgstr "" #: ../Doc/library/multiprocessing.rst:1197 msgid "" "If *lock* is specified then it should be a :class:`Lock` or :class:`RLock` " "object from :mod:`multiprocessing`." msgstr "" #: ../Doc/library/multiprocessing.rst:1200 #: ../Doc/library/multiprocessing.rst:1734 msgid "The :meth:`~threading.Condition.wait_for` method was added." msgstr "" #: ../Doc/library/multiprocessing.rst:1205 msgid "A clone of :class:`threading.Event`." msgstr "" #: ../Doc/library/multiprocessing.rst:1210 msgid "" "A non-recursive lock object: a close analog of :class:`threading.Lock`. Once " "a process or thread has acquired a lock, subsequent attempts to acquire it " "from any process or thread will block until it is released; any process or " "thread may release it. The concepts and behaviors of :class:`threading." "Lock` as it applies to threads are replicated here in :class:" "`multiprocessing.Lock` as it applies to either processes or threads, except " "as noted." msgstr "" #: ../Doc/library/multiprocessing.rst:1218 msgid "" "Note that :class:`Lock` is actually a factory function which returns an " "instance of ``multiprocessing.synchronize.Lock`` initialized with a default " "context." msgstr "" #: ../Doc/library/multiprocessing.rst:1222 msgid "" ":class:`Lock` supports the :term:`context manager` protocol and thus may be " "used in :keyword:`with` statements." msgstr "" #: ../Doc/library/multiprocessing.rst:1227 #: ../Doc/library/multiprocessing.rst:1278 msgid "Acquire a lock, blocking or non-blocking." msgstr "" #: ../Doc/library/multiprocessing.rst:1229 msgid "" "With the *block* argument set to ``True`` (the default), the method call " "will block until the lock is in an unlocked state, then set it to locked and " "return ``True``. Note that the name of this first argument differs from " "that in :meth:`threading.Lock.acquire`." msgstr "" #: ../Doc/library/multiprocessing.rst:1234 msgid "" "With the *block* argument set to ``False``, the method call does not block. " "If the lock is currently in a locked state, return ``False``; otherwise set " "the lock to a locked state and return ``True``." msgstr "" #: ../Doc/library/multiprocessing.rst:1238 msgid "" "When invoked with a positive, floating-point value for *timeout*, block for " "at most the number of seconds specified by *timeout* as long as the lock can " "not be acquired. Invocations with a negative value for *timeout* are " "equivalent to a *timeout* of zero. Invocations with a *timeout* value of " "``None`` (the default) set the timeout period to infinite. Note that the " "treatment of negative or ``None`` values for *timeout* differs from the " "implemented behavior in :meth:`threading.Lock.acquire`. The *timeout* " "argument has no practical implications if the *block* argument is set to " "``False`` and is thus ignored. Returns ``True`` if the lock has been " "acquired or ``False`` if the timeout period has elapsed." msgstr "" #: ../Doc/library/multiprocessing.rst:1253 msgid "" "Release a lock. This can be called from any process or thread, not only the " "process or thread which originally acquired the lock." msgstr "" #: ../Doc/library/multiprocessing.rst:1256 msgid "" "Behavior is the same as in :meth:`threading.Lock.release` except that when " "invoked on an unlocked lock, a :exc:`ValueError` is raised." msgstr "" #: ../Doc/library/multiprocessing.rst:1262 msgid "" "A recursive lock object: a close analog of :class:`threading.RLock`. A " "recursive lock must be released by the process or thread that acquired it. " "Once a process or thread has acquired a recursive lock, the same process or " "thread may acquire it again without blocking; that process or thread must " "release it once for each time it has been acquired." msgstr "" #: ../Doc/library/multiprocessing.rst:1268 msgid "" "Note that :class:`RLock` is actually a factory function which returns an " "instance of ``multiprocessing.synchronize.RLock`` initialized with a default " "context." msgstr "" #: ../Doc/library/multiprocessing.rst:1272 msgid "" ":class:`RLock` supports the :term:`context manager` protocol and thus may be " "used in :keyword:`with` statements." msgstr "" #: ../Doc/library/multiprocessing.rst:1280 msgid "" "When invoked with the *block* argument set to ``True``, block until the lock " "is in an unlocked state (not owned by any process or thread) unless the lock " "is already owned by the current process or thread. The current process or " "thread then takes ownership of the lock (if it does not already have " "ownership) and the recursion level inside the lock increments by one, " "resulting in a return value of ``True``. Note that there are several " "differences in this first argument's behavior compared to the implementation " "of :meth:`threading.RLock.acquire`, starting with the name of the argument " "itself." msgstr "" #: ../Doc/library/multiprocessing.rst:1290 msgid "" "When invoked with the *block* argument set to ``False``, do not block. If " "the lock has already been acquired (and thus is owned) by another process or " "thread, the current process or thread does not take ownership and the " "recursion level within the lock is not changed, resulting in a return value " "of ``False``. If the lock is in an unlocked state, the current process or " "thread takes ownership and the recursion level is incremented, resulting in " "a return value of ``True``." msgstr "" #: ../Doc/library/multiprocessing.rst:1298 msgid "" "Use and behaviors of the *timeout* argument are the same as in :meth:`Lock." "acquire`. Note that some of these behaviors of *timeout* differ from the " "implemented behaviors in :meth:`threading.RLock.acquire`." msgstr "" #: ../Doc/library/multiprocessing.rst:1305 msgid "" "Release a lock, decrementing the recursion level. If after the decrement " "the recursion level is zero, reset the lock to unlocked (not owned by any " "process or thread) and if any other processes or 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 process or thread." msgstr "" #: ../Doc/library/multiprocessing.rst:1313 msgid "" "Only call this method when the calling process or thread owns the lock. An :" "exc:`AssertionError` is raised if this method is called by a process or " "thread other than the owner or if the lock is in an unlocked (unowned) " "state. Note that the type of exception raised in this situation differs " "from the implemented behavior in :meth:`threading.RLock.release`." msgstr "" #: ../Doc/library/multiprocessing.rst:1322 msgid "A semaphore object: a close analog of :class:`threading.Semaphore`." msgstr "" #: ../Doc/library/multiprocessing.rst:1329 msgid "" "On Mac OS X, ``sem_timedwait`` is unsupported, so calling ``acquire()`` with " "a timeout will emulate that function's behavior using a sleeping loop." msgstr "" #: ../Doc/library/multiprocessing.rst:1334 msgid "" "If the SIGINT signal generated by :kbd:`Ctrl-C` arrives while the main " "thread is blocked by a call to :meth:`BoundedSemaphore.acquire`, :meth:`Lock." "acquire`, :meth:`RLock.acquire`, :meth:`Semaphore.acquire`, :meth:`Condition." "acquire` or :meth:`Condition.wait` then the call will be immediately " "interrupted and :exc:`KeyboardInterrupt` will be raised." msgstr "" #: ../Doc/library/multiprocessing.rst:1340 msgid "" "This differs from the behaviour of :mod:`threading` where SIGINT will be " "ignored while the equivalent blocking calls are in progress." msgstr "" #: ../Doc/library/multiprocessing.rst:1345 msgid "" "Some of this package's functionality requires a functioning shared semaphore " "implementation on the host operating system. Without one, the :mod:" "`multiprocessing.synchronize` module will be disabled, and attempts to " "import it will result in an :exc:`ImportError`. See :issue:`3770` for " "additional information." msgstr "" #: ../Doc/library/multiprocessing.rst:1353 msgid "Shared :mod:`ctypes` Objects" msgstr "" #: ../Doc/library/multiprocessing.rst:1355 msgid "" "It is possible to create shared objects using shared memory which can be " "inherited by child processes." msgstr "" #: ../Doc/library/multiprocessing.rst:1360 msgid "" "Return a :mod:`ctypes` object allocated from shared memory. By default the " "return value is actually a synchronized wrapper for the object. The object " "itself can be accessed via the *value* attribute of a :class:`Value`." msgstr "" #: ../Doc/library/multiprocessing.rst:1364 #: ../Doc/library/multiprocessing.rst:1451 msgid "" "*typecode_or_type* determines the type of the returned object: it is either " "a ctypes type or a one character typecode of the kind used by the :mod:" "`array` module. *\\*args* is passed on to the constructor for the type." msgstr "" #: ../Doc/library/multiprocessing.rst:1368 msgid "" "If *lock* is ``True`` (the default) then a new recursive lock object is " "created to synchronize access to the value. If *lock* is a :class:`Lock` " "or :class:`RLock` object then that will be used to synchronize access to the " "value. If *lock* is ``False`` then access to the returned object will not " "be automatically protected by a lock, so it will not necessarily be " "\"process-safe\"." msgstr "" #: ../Doc/library/multiprocessing.rst:1375 msgid "" "Operations like ``+=`` which involve a read and write are not atomic. So " "if, for instance, you want to atomically increment a shared value it is " "insufficient to just do ::" msgstr "" #: ../Doc/library/multiprocessing.rst:1381 msgid "" "Assuming the associated lock is recursive (which it is by default) you can " "instead do ::" msgstr "" #: ../Doc/library/multiprocessing.rst:1387 #: ../Doc/library/multiprocessing.rst:1477 #: ../Doc/library/multiprocessing.rst:1492 msgid "Note that *lock* is a keyword-only argument." msgstr "" #: ../Doc/library/multiprocessing.rst:1391 msgid "" "Return a ctypes array allocated from shared memory. By default the return " "value is actually a synchronized wrapper for the array." msgstr "" #: ../Doc/library/multiprocessing.rst:1394 msgid "" "*typecode_or_type* determines the type of the elements of the returned " "array: it is either a ctypes type or a one character typecode of the kind " "used by the :mod:`array` module. If *size_or_initializer* is an integer, " "then it determines the length of the array, and the array will be initially " "zeroed. Otherwise, *size_or_initializer* is a sequence which is used to " "initialize the array and whose length determines the length of the array." msgstr "" #: ../Doc/library/multiprocessing.rst:1401 msgid "" "If *lock* is ``True`` (the default) then a new lock object is created to " "synchronize access to the value. If *lock* is a :class:`Lock` or :class:" "`RLock` object then that will be used to synchronize access to the value. " "If *lock* is ``False`` then access to the returned object will not be " "automatically protected by a lock, so it will not necessarily be \"process-" "safe\"." msgstr "" #: ../Doc/library/multiprocessing.rst:1408 msgid "Note that *lock* is a keyword only argument." msgstr "" #: ../Doc/library/multiprocessing.rst:1410 msgid "" "Note that an array of :data:`ctypes.c_char` has *value* and *raw* attributes " "which allow one to use it to store and retrieve strings." msgstr "" #: ../Doc/library/multiprocessing.rst:1415 msgid "The :mod:`multiprocessing.sharedctypes` module" msgstr "" #: ../Doc/library/multiprocessing.rst:1420 msgid "" "The :mod:`multiprocessing.sharedctypes` module provides functions for " "allocating :mod:`ctypes` objects from shared memory which can be inherited " "by child processes." msgstr "" #: ../Doc/library/multiprocessing.rst:1426 msgid "" "Although it is possible to store a pointer in shared memory remember that " "this will refer to a location in the address space of a specific process. " "However, the pointer is quite likely to be invalid in the context of a " "second process and trying to dereference the pointer from the second process " "may cause a crash." msgstr "" #: ../Doc/library/multiprocessing.rst:1434 msgid "Return a ctypes array allocated from shared memory." msgstr "" #: ../Doc/library/multiprocessing.rst:1436 msgid "" "*typecode_or_type* determines the type of the elements of the returned " "array: it is either a ctypes type or a one character typecode of the kind " "used by the :mod:`array` module. If *size_or_initializer* is an integer " "then it determines the length of the array, and the array will be initially " "zeroed. Otherwise *size_or_initializer* is a sequence which is used to " "initialize the array and whose length determines the length of the array." msgstr "" #: ../Doc/library/multiprocessing.rst:1443 msgid "" "Note that setting and getting an element is potentially non-atomic -- use :" "func:`Array` instead to make sure that access is automatically synchronized " "using a lock." msgstr "" #: ../Doc/library/multiprocessing.rst:1449 msgid "Return a ctypes object allocated from shared memory." msgstr "" #: ../Doc/library/multiprocessing.rst:1455 msgid "" "Note that setting and getting the value is potentially non-atomic -- use :" "func:`Value` instead to make sure that access is automatically synchronized " "using a lock." msgstr "" #: ../Doc/library/multiprocessing.rst:1459 msgid "" "Note that an array of :data:`ctypes.c_char` has ``value`` and ``raw`` " "attributes which allow one to use it to store and retrieve strings -- see " "documentation for :mod:`ctypes`." msgstr "" #: ../Doc/library/multiprocessing.rst:1465 msgid "" "The same as :func:`RawArray` except that depending on the value of *lock* a " "process-safe synchronization wrapper may be returned instead of a raw ctypes " "array." msgstr "" #: ../Doc/library/multiprocessing.rst:1469 #: ../Doc/library/multiprocessing.rst:1485 msgid "" "If *lock* is ``True`` (the default) then a new lock object is created to " "synchronize access to the value. If *lock* is a :class:`~multiprocessing." "Lock` or :class:`~multiprocessing.RLock` object then that will be used to " "synchronize access to the value. If *lock* is ``False`` then access to the " "returned object will not be automatically protected by a lock, so it will " "not necessarily be \"process-safe\"." msgstr "" #: ../Doc/library/multiprocessing.rst:1481 msgid "" "The same as :func:`RawValue` except that depending on the value of *lock* a " "process-safe synchronization wrapper may be returned instead of a raw ctypes " "object." msgstr "" #: ../Doc/library/multiprocessing.rst:1496 msgid "" "Return a ctypes object allocated from shared memory which is a copy of the " "ctypes object *obj*." msgstr "" #: ../Doc/library/multiprocessing.rst:1501 msgid "" "Return a process-safe wrapper object for a ctypes object which uses *lock* " "to synchronize access. If *lock* is ``None`` (the default) then a :class:" "`multiprocessing.RLock` object is created automatically." msgstr "" #: ../Doc/library/multiprocessing.rst:1505 msgid "" "A synchronized wrapper will have two methods in addition to those of the " "object it wraps: :meth:`get_obj` returns the wrapped object and :meth:" "`get_lock` returns the lock object used for synchronization." msgstr "" #: ../Doc/library/multiprocessing.rst:1509 msgid "" "Note that accessing the ctypes object through the wrapper can be a lot " "slower than accessing the raw ctypes object." msgstr "" #: ../Doc/library/multiprocessing.rst:1512 msgid "Synchronized objects support the :term:`context manager` protocol." msgstr "" #: ../Doc/library/multiprocessing.rst:1516 msgid "" "The table below compares the syntax for creating shared ctypes objects from " "shared memory with the normal ctypes syntax. (In the table ``MyStruct`` is " "some subclass of :class:`ctypes.Structure`.)" msgstr "" #: ../Doc/library/multiprocessing.rst:1521 msgid "ctypes" msgstr "ctypes" #: ../Doc/library/multiprocessing.rst:1521 msgid "sharedctypes using type" msgstr "" #: ../Doc/library/multiprocessing.rst:1521 msgid "sharedctypes using typecode" msgstr "" #: ../Doc/library/multiprocessing.rst:1523 msgid "c_double(2.4)" msgstr "c_double(2.4)" #: ../Doc/library/multiprocessing.rst:1523 msgid "RawValue(c_double, 2.4)" msgstr "RawValue(c_double, 2.4)" #: ../Doc/library/multiprocessing.rst:1523 msgid "RawValue('d', 2.4)" msgstr "RawValue('d', 2.4)" #: ../Doc/library/multiprocessing.rst:1524 msgid "MyStruct(4, 6)" msgstr "MyStruct(4, 6)" #: ../Doc/library/multiprocessing.rst:1524 msgid "RawValue(MyStruct, 4, 6)" msgstr "RawValue(MyStruct, 4, 6)" #: ../Doc/library/multiprocessing.rst:1525 msgid "(c_short * 7)()" msgstr "(c_short * 7)()" #: ../Doc/library/multiprocessing.rst:1525 msgid "RawArray(c_short, 7)" msgstr "RawArray(c_short, 7)" #: ../Doc/library/multiprocessing.rst:1525 msgid "RawArray('h', 7)" msgstr "RawArray('h', 7)" #: ../Doc/library/multiprocessing.rst:1526 msgid "(c_int * 3)(9, 2, 8)" msgstr "(c_int * 3)(9, 2, 8)" #: ../Doc/library/multiprocessing.rst:1526 msgid "RawArray(c_int, (9, 2, 8))" msgstr "RawArray(c_int, (9, 2, 8))" #: ../Doc/library/multiprocessing.rst:1526 msgid "RawArray('i', (9, 2, 8))" msgstr "RawArray('i', (9, 2, 8))" #: ../Doc/library/multiprocessing.rst:1530 msgid "" "Below is an example where a number of ctypes objects are modified by a child " "process::" msgstr "" #: ../Doc/library/multiprocessing.rst:1568 msgid "The results printed are ::" msgstr "" #: ../Doc/library/multiprocessing.rst:1581 msgid "Managers" msgstr "" #: ../Doc/library/multiprocessing.rst:1583 msgid "" "Managers provide a way to create data which can be shared between different " "processes, including sharing over a network between processes running on " "different machines. A manager object controls a server process which manages " "*shared objects*. Other processes can access the shared objects by using " "proxies." msgstr "" #: ../Doc/library/multiprocessing.rst:1591 msgid "" "Returns a started :class:`~multiprocessing.managers.SyncManager` object " "which can be used for sharing objects between processes. The returned " "manager object corresponds to a spawned child process and has methods which " "will create shared objects and return corresponding proxies." msgstr "" #: ../Doc/library/multiprocessing.rst:1599 msgid "" "Manager processes will be shutdown as soon as they are garbage collected or " "their parent process exits. The manager classes are defined in the :mod:" "`multiprocessing.managers` module:" msgstr "" #: ../Doc/library/multiprocessing.rst:1605 msgid "Create a BaseManager object." msgstr "" #: ../Doc/library/multiprocessing.rst:1607 msgid "" "Once created one should call :meth:`start` or ``get_server()." "serve_forever()`` to ensure that the manager object refers to a started " "manager process." msgstr "" #: ../Doc/library/multiprocessing.rst:1610 msgid "" "*address* is the address on which the manager process listens for new " "connections. If *address* is ``None`` then an arbitrary one is chosen." msgstr "" #: ../Doc/library/multiprocessing.rst:1613 msgid "" "*authkey* is the authentication key which will be used to check the validity " "of incoming connections to the server process. If *authkey* is ``None`` " "then ``current_process().authkey`` is used. Otherwise *authkey* is used and " "it must be a byte string." msgstr "" #: ../Doc/library/multiprocessing.rst:1620 msgid "" "Start a subprocess to start the manager. If *initializer* is not ``None`` " "then the subprocess will call ``initializer(*initargs)`` when it starts." msgstr "" #: ../Doc/library/multiprocessing.rst:1625 msgid "" "Returns a :class:`Server` object which represents the actual server under " "the control of the Manager. The :class:`Server` object supports the :meth:" "`serve_forever` method::" msgstr "" #: ../Doc/library/multiprocessing.rst:1634 msgid ":class:`Server` additionally has an :attr:`address` attribute." msgstr "" #: ../Doc/library/multiprocessing.rst:1638 msgid "Connect a local manager object to a remote manager process::" msgstr "" #: ../Doc/library/multiprocessing.rst:1646 msgid "" "Stop the process used by the manager. This is only available if :meth:" "`start` has been used to start the server process." msgstr "" #: ../Doc/library/multiprocessing.rst:1649 msgid "This can be called multiple times." msgstr "" #: ../Doc/library/multiprocessing.rst:1653 msgid "" "A classmethod which can be used for registering a type or callable with the " "manager class." msgstr "" #: ../Doc/library/multiprocessing.rst:1656 msgid "" "*typeid* is a \"type identifier\" which is used to identify a particular " "type of shared object. This must be a string." msgstr "" #: ../Doc/library/multiprocessing.rst:1659 msgid "" "*callable* is a callable used for creating objects for this type " "identifier. If a manager instance will be connected to the server using " "the :meth:`connect` method, or if the *create_method* argument is ``False`` " "then this can be left as ``None``." msgstr "" #: ../Doc/library/multiprocessing.rst:1665 msgid "" "*proxytype* is a subclass of :class:`BaseProxy` which is used to create " "proxies for shared objects with this *typeid*. If ``None`` then a proxy " "class is created automatically." msgstr "" #: ../Doc/library/multiprocessing.rst:1669 msgid "" "*exposed* is used to specify a sequence of method names which proxies for " "this typeid should be allowed to access using :meth:`BaseProxy." "_callmethod`. (If *exposed* is ``None`` then :attr:`proxytype._exposed_` is " "used instead if it exists.) In the case where no exposed list is specified, " "all \"public methods\" of the shared object will be accessible. (Here a " "\"public method\" means any attribute which has a :meth:`~object.__call__` " "method and whose name does not begin with ``'_'``.)" msgstr "" #: ../Doc/library/multiprocessing.rst:1678 msgid "" "*method_to_typeid* is a mapping used to specify the return type of those " "exposed methods which should return a proxy. It maps method names to typeid " "strings. (If *method_to_typeid* is ``None`` then :attr:`proxytype." "_method_to_typeid_` is used instead if it exists.) If a method's name is " "not a key of this mapping or if the mapping is ``None`` then the object " "returned by the method will be copied by value." msgstr "" #: ../Doc/library/multiprocessing.rst:1685 msgid "" "*create_method* determines whether a method should be created with name " "*typeid* which can be used to tell the server process to create a new shared " "object and return a proxy for it. By default it is ``True``." msgstr "" #: ../Doc/library/multiprocessing.rst:1689 msgid ":class:`BaseManager` instances also have one read-only property:" msgstr "" #: ../Doc/library/multiprocessing.rst:1693 msgid "The address used by the manager." msgstr "" #: ../Doc/library/multiprocessing.rst:1695 msgid "" "Manager objects support the context management protocol -- see :ref:" "`typecontextmanager`. :meth:`~contextmanager.__enter__` starts the server " "process (if it has not already started) and then returns the manager " "object. :meth:`~contextmanager.__exit__` calls :meth:`shutdown`." msgstr "" #: ../Doc/library/multiprocessing.rst:1701 msgid "" "In previous versions :meth:`~contextmanager.__enter__` did not start the " "manager's server process if it was not already started." msgstr "" #: ../Doc/library/multiprocessing.rst:1706 msgid "" "A subclass of :class:`BaseManager` which can be used for the synchronization " "of processes. Objects of this type are returned by :func:`multiprocessing." "Manager`." msgstr "" #: ../Doc/library/multiprocessing.rst:1710 msgid "" "Its methods create and return :ref:`multiprocessing-proxy_objects` for a " "number of commonly used data types to be synchronized across processes. This " "notably includes shared lists and dictionaries." msgstr "" #: ../Doc/library/multiprocessing.rst:1716 msgid "" "Create a shared :class:`threading.Barrier` object and return a proxy for it." msgstr "" #: ../Doc/library/multiprocessing.rst:1723 msgid "" "Create a shared :class:`threading.BoundedSemaphore` object and return a " "proxy for it." msgstr "" #: ../Doc/library/multiprocessing.rst:1728 msgid "" "Create a shared :class:`threading.Condition` object and return a proxy for " "it." msgstr "" #: ../Doc/library/multiprocessing.rst:1731 msgid "" "If *lock* is supplied then it should be a proxy for a :class:`threading." "Lock` or :class:`threading.RLock` object." msgstr "" #: ../Doc/library/multiprocessing.rst:1739 msgid "" "Create a shared :class:`threading.Event` object and return a proxy for it." msgstr "" #: ../Doc/library/multiprocessing.rst:1743 msgid "" "Create a shared :class:`threading.Lock` object and return a proxy for it." msgstr "" #: ../Doc/library/multiprocessing.rst:1747 msgid "Create a shared :class:`Namespace` object and return a proxy for it." msgstr "" #: ../Doc/library/multiprocessing.rst:1751 msgid "Create a shared :class:`queue.Queue` object and return a proxy for it." msgstr "" #: ../Doc/library/multiprocessing.rst:1755 msgid "" "Create a shared :class:`threading.RLock` object and return a proxy for it." msgstr "" #: ../Doc/library/multiprocessing.rst:1759 msgid "" "Create a shared :class:`threading.Semaphore` object and return a proxy for " "it." msgstr "" #: ../Doc/library/multiprocessing.rst:1764 msgid "Create an array and return a proxy for it." msgstr "" #: ../Doc/library/multiprocessing.rst:1768 msgid "" "Create an object with a writable ``value`` attribute and return a proxy for " "it." msgstr "" #: ../Doc/library/multiprocessing.rst:1775 msgid "Create a shared :class:`dict` object and return a proxy for it." msgstr "" #: ../Doc/library/multiprocessing.rst:1780 msgid "Create a shared :class:`list` object and return a proxy for it." msgstr "" #: ../Doc/library/multiprocessing.rst:1782 msgid "" "Shared objects are capable of being nested. For example, a shared container " "object such as a shared list can contain other shared objects which will all " "be managed and synchronized by the :class:`SyncManager`." msgstr "" #: ../Doc/library/multiprocessing.rst:1789 msgid "A type that can register with :class:`SyncManager`." msgstr "" #: ../Doc/library/multiprocessing.rst:1791 msgid "" "A namespace object has no public methods, but does have writable attributes. " "Its representation shows the values of its attributes." msgstr "" #: ../Doc/library/multiprocessing.rst:1794 msgid "" "However, when using a proxy for a namespace object, an attribute beginning " "with ``'_'`` will be an attribute of the proxy and not an attribute of the " "referent:" msgstr "" #: ../Doc/library/multiprocessing.rst:1810 msgid "Customized managers" msgstr "" #: ../Doc/library/multiprocessing.rst:1812 msgid "" "To create one's own manager, one creates a subclass of :class:`BaseManager` " "and uses the :meth:`~BaseManager.register` classmethod to register new types " "or callables with the manager class. For example::" msgstr "" #: ../Doc/library/multiprocessing.rst:1837 msgid "Using a remote manager" msgstr "" #: ../Doc/library/multiprocessing.rst:1839 msgid "" "It is possible to run a manager server on one machine and have clients use " "it from other machines (assuming that the firewalls involved allow it)." msgstr "" #: ../Doc/library/multiprocessing.rst:1842 msgid "" "Running the following commands creates a server for a single shared queue " "which remote clients can access::" msgstr "" #: ../Doc/library/multiprocessing.rst:1854 msgid "One client can access the server as follows::" msgstr "" #: ../Doc/library/multiprocessing.rst:1864 msgid "Another client can also use it::" msgstr "" #: ../Doc/library/multiprocessing.rst:1875 msgid "" "Local processes can also access that queue, using the code from above on the " "client to access it remotely::" msgstr "" #: ../Doc/library/multiprocessing.rst:1900 msgid "Proxy Objects" msgstr "" #: ../Doc/library/multiprocessing.rst:1902 msgid "" "A proxy is an object which *refers* to a shared object which lives " "(presumably) in a different process. The shared object is said to be the " "*referent* of the proxy. Multiple proxy objects may have the same referent." msgstr "" #: ../Doc/library/multiprocessing.rst:1906 msgid "" "A proxy object has methods which invoke corresponding methods of its " "referent (although not every method of the referent will necessarily be " "available through the proxy). In this way, a proxy can be used just like " "its referent can:" msgstr "" #: ../Doc/library/multiprocessing.rst:1924 msgid "" "Notice that applying :func:`str` to a proxy will return the representation " "of the referent, whereas applying :func:`repr` will return the " "representation of the proxy." msgstr "" #: ../Doc/library/multiprocessing.rst:1928 msgid "" "An important feature of proxy objects is that they are picklable so they can " "be passed between processes. As such, a referent can contain :ref:" "`multiprocessing-proxy_objects`. This permits nesting of these managed " "lists, dicts, and other :ref:`multiprocessing-proxy_objects`:" msgstr "" #: ../Doc/library/multiprocessing.rst:1944 msgid "Similarly, dict and list proxies may be nested inside one another::" msgstr "" #: ../Doc/library/multiprocessing.rst:1957 msgid "" "If standard (non-proxy) :class:`list` or :class:`dict` objects are contained " "in a referent, modifications to those mutable values will not be propagated " "through the manager because the proxy has no way of knowing when the values " "contained within are modified. However, storing a value in a container " "proxy (which triggers a ``__setitem__`` on the proxy object) does propagate " "through the manager and so to effectively modify such an item, one could re-" "assign the modified value to the container proxy::" msgstr "" #: ../Doc/library/multiprocessing.rst:1976 msgid "" "This approach is perhaps less convenient than employing nested :ref:" "`multiprocessing-proxy_objects` for most use cases but also demonstrates a " "level of control over the synchronization." msgstr "" #: ../Doc/library/multiprocessing.rst:1982 msgid "" "The proxy types in :mod:`multiprocessing` do nothing to support comparisons " "by value. So, for instance, we have:" msgstr "" #: ../Doc/library/multiprocessing.rst:1990 msgid "" "One should just use a copy of the referent instead when making comparisons." msgstr "" #: ../Doc/library/multiprocessing.rst:1994 msgid "Proxy objects are instances of subclasses of :class:`BaseProxy`." msgstr "" #: ../Doc/library/multiprocessing.rst:1998 msgid "Call and return the result of a method of the proxy's referent." msgstr "" #: ../Doc/library/multiprocessing.rst:2000 msgid "" "If ``proxy`` is a proxy whose referent is ``obj`` then the expression ::" msgstr "" #: ../Doc/library/multiprocessing.rst:2004 msgid "will evaluate the expression ::" msgstr "" #: ../Doc/library/multiprocessing.rst:2008 msgid "in the manager's process." msgstr "" #: ../Doc/library/multiprocessing.rst:2010 msgid "" "The returned value will be a copy of the result of the call or a proxy to a " "new shared object -- see documentation for the *method_to_typeid* argument " "of :meth:`BaseManager.register`." msgstr "" #: ../Doc/library/multiprocessing.rst:2014 msgid "" "If an exception is raised by the call, then is re-raised by :meth:" "`_callmethod`. If some other exception is raised in the manager's process " "then this is converted into a :exc:`RemoteError` exception and is raised by :" "meth:`_callmethod`." msgstr "" #: ../Doc/library/multiprocessing.rst:2019 msgid "" "Note in particular that an exception will be raised if *methodname* has not " "been *exposed*." msgstr "" #: ../Doc/library/multiprocessing.rst:2022 msgid "An example of the usage of :meth:`_callmethod`:" msgstr "" #: ../Doc/library/multiprocessing.rst:2038 msgid "Return a copy of the referent." msgstr "" #: ../Doc/library/multiprocessing.rst:2040 msgid "If the referent is unpicklable then this will raise an exception." msgstr "" #: ../Doc/library/multiprocessing.rst:2044 msgid "Return a representation of the proxy object." msgstr "" #: ../Doc/library/multiprocessing.rst:2048 msgid "Return the representation of the referent." msgstr "" #: ../Doc/library/multiprocessing.rst:2052 msgid "Cleanup" msgstr "" #: ../Doc/library/multiprocessing.rst:2054 msgid "" "A proxy object uses a weakref callback so that when it gets garbage " "collected it deregisters itself from the manager which owns its referent." msgstr "" #: ../Doc/library/multiprocessing.rst:2057 msgid "" "A shared object gets deleted from the manager process when there are no " "longer any proxies referring to it." msgstr "" #: ../Doc/library/multiprocessing.rst:2062 msgid "Process Pools" msgstr "" #: ../Doc/library/multiprocessing.rst:2067 msgid "" "One can create a pool of processes which will carry out tasks submitted to " "it with the :class:`Pool` class." msgstr "" #: ../Doc/library/multiprocessing.rst:2072 msgid "" "A process pool object which controls a pool of worker processes to which " "jobs can be submitted. It supports asynchronous results with timeouts and " "callbacks and has a parallel map implementation." msgstr "" #: ../Doc/library/multiprocessing.rst:2076 msgid "" "*processes* is the number of worker processes to use. If *processes* is " "``None`` then the number returned by :func:`os.cpu_count` is used." msgstr "" #: ../Doc/library/multiprocessing.rst:2079 msgid "" "If *initializer* is not ``None`` then each worker process will call " "``initializer(*initargs)`` when it starts." msgstr "" #: ../Doc/library/multiprocessing.rst:2082 msgid "" "*maxtasksperchild* is the number of tasks a worker process can complete " "before it will exit and be replaced with a fresh worker process, to enable " "unused resources to be freed. The default *maxtasksperchild* is ``None``, " "which means worker processes will live as long as the pool." msgstr "" #: ../Doc/library/multiprocessing.rst:2087 msgid "" "*context* can be used to specify the context used for starting the worker " "processes. Usually a pool is created using the function :func:" "`multiprocessing.Pool` or the :meth:`Pool` method of a context object. In " "both cases *context* is set appropriately." msgstr "" #: ../Doc/library/multiprocessing.rst:2093 msgid "" "Note that the methods of the pool object should only be called by the " "process which created the pool." msgstr "" #: ../Doc/library/multiprocessing.rst:2096 msgid "*maxtasksperchild*" msgstr "" #: ../Doc/library/multiprocessing.rst:2099 msgid "*context*" msgstr "*context*" #: ../Doc/library/multiprocessing.rst:2104 msgid "" "Worker processes within a :class:`Pool` typically live for the complete " "duration of the Pool's work queue. A frequent pattern found in other systems " "(such as Apache, mod_wsgi, etc) to free resources held by workers is to " "allow a worker within a pool to complete only a set amount of work before " "being exiting, being cleaned up and a new process spawned to replace the old " "one. The *maxtasksperchild* argument to the :class:`Pool` exposes this " "ability to the end user." msgstr "" #: ../Doc/library/multiprocessing.rst:2114 msgid "" "Call *func* with arguments *args* and keyword arguments *kwds*. It blocks " "until the result is ready. Given this blocks, :meth:`apply_async` is better " "suited for performing work in parallel. Additionally, *func* is only " "executed in one of the workers of the pool." msgstr "" #: ../Doc/library/multiprocessing.rst:2121 msgid "A variant of the :meth:`apply` method which returns a result object." msgstr "" #: ../Doc/library/multiprocessing.rst:2123 #: ../Doc/library/multiprocessing.rst:2148 msgid "" "If *callback* is specified then it should be a callable which accepts a " "single argument. When the result becomes ready *callback* is applied to it, " "that is unless the call failed, in which case the *error_callback* is " "applied instead." msgstr "" #: ../Doc/library/multiprocessing.rst:2128 #: ../Doc/library/multiprocessing.rst:2153 msgid "" "If *error_callback* is specified then it should be a callable which accepts " "a single argument. If the target function fails, then the *error_callback* " "is called with the exception instance." msgstr "" #: ../Doc/library/multiprocessing.rst:2132 #: ../Doc/library/multiprocessing.rst:2157 msgid "" "Callbacks should complete immediately since otherwise the thread which " "handles the results will get blocked." msgstr "" #: ../Doc/library/multiprocessing.rst:2137 msgid "" "A parallel equivalent of the :func:`map` built-in function (it supports only " "one *iterable* argument though). It blocks until the result is ready." msgstr "" #: ../Doc/library/multiprocessing.rst:2140 msgid "" "This method chops the iterable into a number of chunks which it submits to " "the process pool as separate tasks. The (approximate) size of these chunks " "can be specified by setting *chunksize* to a positive integer." msgstr "" #: ../Doc/library/multiprocessing.rst:2146 msgid "A variant of the :meth:`.map` method which returns a result object." msgstr "" #: ../Doc/library/multiprocessing.rst:2162 msgid "A lazier version of :meth:`map`." msgstr "" #: ../Doc/library/multiprocessing.rst:2164 msgid "" "The *chunksize* argument is the same as the one used by the :meth:`.map` " "method. For very long iterables using a large value for *chunksize* can " "make the job complete **much** faster than using the default value of ``1``." msgstr "" #: ../Doc/library/multiprocessing.rst:2169 msgid "" "Also if *chunksize* is ``1`` then the :meth:`!next` method of the iterator " "returned by the :meth:`imap` method has an optional *timeout* parameter: " "``next(timeout)`` will raise :exc:`multiprocessing.TimeoutError` if the " "result cannot be returned within *timeout* seconds." msgstr "" #: ../Doc/library/multiprocessing.rst:2176 msgid "" "The same as :meth:`imap` except that the ordering of the results from the " "returned iterator should be considered arbitrary. (Only when there is only " "one worker process is the order guaranteed to be \"correct\".)" msgstr "" #: ../Doc/library/multiprocessing.rst:2182 msgid "" "Like :meth:`map` except that the elements of the *iterable* are expected to " "be iterables that are unpacked as arguments." msgstr "" #: ../Doc/library/multiprocessing.rst:2185 msgid "" "Hence an *iterable* of ``[(1,2), (3, 4)]`` results in ``[func(1,2), " "func(3,4)]``." msgstr "" #: ../Doc/library/multiprocessing.rst:2192 msgid "" "A combination of :meth:`starmap` and :meth:`map_async` that iterates over " "*iterable* of iterables and calls *func* with the iterables unpacked. " "Returns a result object." msgstr "" #: ../Doc/library/multiprocessing.rst:2200 msgid "" "Prevents any more tasks from being submitted to the pool. Once all the " "tasks have been completed the worker processes will exit." msgstr "" #: ../Doc/library/multiprocessing.rst:2205 msgid "" "Stops the worker processes immediately without completing outstanding work. " "When the pool object is garbage collected :meth:`terminate` will be called " "immediately." msgstr "" #: ../Doc/library/multiprocessing.rst:2211 msgid "" "Wait for the worker processes to exit. One must call :meth:`close` or :meth:" "`terminate` before using :meth:`join`." msgstr "" #: ../Doc/library/multiprocessing.rst:2214 msgid "" "Pool objects now support the context management protocol -- see :ref:" "`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the pool " "object, and :meth:`~contextmanager.__exit__` calls :meth:`terminate`." msgstr "" #: ../Doc/library/multiprocessing.rst:2222 msgid "" "The class of the result returned by :meth:`Pool.apply_async` and :meth:`Pool." "map_async`." msgstr "" #: ../Doc/library/multiprocessing.rst:2227 msgid "" "Return the result when it arrives. If *timeout* is not ``None`` and the " "result does not arrive within *timeout* seconds then :exc:`multiprocessing." "TimeoutError` is raised. If the remote call raised an exception then that " "exception will be reraised by :meth:`get`." msgstr "" #: ../Doc/library/multiprocessing.rst:2234 msgid "Wait until the result is available or until *timeout* seconds pass." msgstr "" #: ../Doc/library/multiprocessing.rst:2238 msgid "Return whether the call has completed." msgstr "" #: ../Doc/library/multiprocessing.rst:2242 msgid "" "Return whether the call completed without raising an exception. Will raise :" "exc:`AssertionError` if the result is not ready." msgstr "" #: ../Doc/library/multiprocessing.rst:2245 msgid "The following example demonstrates the use of a pool::" msgstr "" #: ../Doc/library/multiprocessing.rst:2272 msgid "Listeners and Clients" msgstr "" #: ../Doc/library/multiprocessing.rst:2277 msgid "" "Usually message passing between processes is done using queues or by using :" "class:`~Connection` objects returned by :func:`~multiprocessing.Pipe`." msgstr "" #: ../Doc/library/multiprocessing.rst:2281 msgid "" "However, the :mod:`multiprocessing.connection` module allows some extra " "flexibility. It basically gives a high level message oriented API for " "dealing with sockets or Windows named pipes. It also has support for " "*digest authentication* using the :mod:`hmac` module, and for polling " "multiple connections at the same time." msgstr "" #: ../Doc/library/multiprocessing.rst:2290 msgid "" "Send a randomly generated message to the other end of the connection and " "wait for a reply." msgstr "" #: ../Doc/library/multiprocessing.rst:2293 msgid "" "If the reply matches the digest of the message using *authkey* as the key " "then a welcome message is sent to the other end of the connection. " "Otherwise :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" #: ../Doc/library/multiprocessing.rst:2299 msgid "" "Receive a message, calculate the digest of the message using *authkey* as " "the key, and then send the digest back." msgstr "" #: ../Doc/library/multiprocessing.rst:2302 msgid "" "If a welcome message is not received, then :exc:`~multiprocessing." "AuthenticationError` is raised." msgstr "" #: ../Doc/library/multiprocessing.rst:2307 msgid "" "Attempt to set up a connection to the listener which is using address " "*address*, returning a :class:`~Connection`." msgstr "" #: ../Doc/library/multiprocessing.rst:2310 msgid "" "The type of the connection is determined by *family* argument, but this can " "generally be omitted since it can usually be inferred from the format of " "*address*. (See :ref:`multiprocessing-address-formats`)" msgstr "" #: ../Doc/library/multiprocessing.rst:2314 #: ../Doc/library/multiprocessing.rst:2349 msgid "" "If *authkey* is given and not None, it should be a byte string and will be " "used as the secret key for an HMAC-based authentication challenge. No " "authentication is done if *authkey* is None. :exc:`~multiprocessing." "AuthenticationError` is raised if authentication fails. See :ref:" "`multiprocessing-auth-keys`." msgstr "" #: ../Doc/library/multiprocessing.rst:2322 msgid "" "A wrapper for a bound socket or Windows named pipe which is 'listening' for " "connections." msgstr "" #: ../Doc/library/multiprocessing.rst:2325 msgid "" "*address* is the address to be used by the bound socket or named pipe of the " "listener object." msgstr "" #: ../Doc/library/multiprocessing.rst:2330 msgid "" "If an address of '0.0.0.0' is used, the address will not be a connectable " "end point on Windows. If you require a connectable end-point, you should use " "'127.0.0.1'." msgstr "" #: ../Doc/library/multiprocessing.rst:2334 msgid "" "*family* is the type of socket (or named pipe) to use. This can be one of " "the strings ``'AF_INET'`` (for a TCP socket), ``'AF_UNIX'`` (for a Unix " "domain socket) or ``'AF_PIPE'`` (for a Windows named pipe). Of these only " "the first is guaranteed to be available. If *family* is ``None`` then the " "family is inferred from the format of *address*. If *address* is also " "``None`` then a default is chosen. This default is the family which is " "assumed to be the fastest available. See :ref:`multiprocessing-address-" "formats`. Note that if *family* is ``'AF_UNIX'`` and address is ``None`` " "then the socket will be created in a private temporary directory created " "using :func:`tempfile.mkstemp`." msgstr "" #: ../Doc/library/multiprocessing.rst:2345 msgid "" "If the listener object uses a socket then *backlog* (1 by default) is passed " "to the :meth:`~socket.socket.listen` method of the socket once it has been " "bound." msgstr "" #: ../Doc/library/multiprocessing.rst:2357 msgid "" "Accept a connection on the bound socket or named pipe of the listener object " "and return a :class:`~Connection` object. If authentication is attempted and " "fails, then :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" #: ../Doc/library/multiprocessing.rst:2364 msgid "" "Close the bound socket or named pipe of the listener object. This is called " "automatically when the listener is garbage collected. However it is " "advisable to call it explicitly." msgstr "" #: ../Doc/library/multiprocessing.rst:2368 msgid "Listener objects have the following read-only properties:" msgstr "" #: ../Doc/library/multiprocessing.rst:2372 msgid "The address which is being used by the Listener object." msgstr "" #: ../Doc/library/multiprocessing.rst:2376 msgid "" "The address from which the last accepted connection came. If this is " "unavailable then it is ``None``." msgstr "" #: ../Doc/library/multiprocessing.rst:2379 msgid "" "Listener objects now support the context management protocol -- see :ref:" "`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the " "listener object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." msgstr "" #: ../Doc/library/multiprocessing.rst:2386 msgid "" "Wait till an object in *object_list* is ready. Returns the list of those " "objects in *object_list* which are ready. If *timeout* is a float then the " "call blocks for at most that many seconds. If *timeout* is ``None`` then it " "will block for an unlimited period. A negative timeout is equivalent to a " "zero timeout." msgstr "" #: ../Doc/library/multiprocessing.rst:2392 msgid "" "For both Unix and Windows, an object can appear in *object_list* if it is" msgstr "" #: ../Doc/library/multiprocessing.rst:2395 msgid "a readable :class:`~multiprocessing.connection.Connection` object;" msgstr "" #: ../Doc/library/multiprocessing.rst:2396 msgid "a connected and readable :class:`socket.socket` object; or" msgstr "" #: ../Doc/library/multiprocessing.rst:2397 msgid "" "the :attr:`~multiprocessing.Process.sentinel` attribute of a :class:" "`~multiprocessing.Process` object." msgstr "" #: ../Doc/library/multiprocessing.rst:2400 msgid "" "A connection or socket object is ready when there is data available to be " "read from it, or the other end has been closed." msgstr "" #: ../Doc/library/multiprocessing.rst:2403 msgid "" "**Unix**: ``wait(object_list, timeout)`` almost equivalent ``select." "select(object_list, [], [], timeout)``. The difference is that, if :func:" "`select.select` is interrupted by a signal, it can raise :exc:`OSError` with " "an error number of ``EINTR``, whereas :func:`wait` will not." msgstr "" #: ../Doc/library/multiprocessing.rst:2409 msgid "" "**Windows**: An item in *object_list* must either be an integer handle which " "is waitable (according to the definition used by the documentation of the " "Win32 function ``WaitForMultipleObjects()``) or it can be an object with a :" "meth:`fileno` method which returns a socket handle or pipe handle. (Note " "that pipe handles and socket handles are **not** waitable handles.)" msgstr "" #: ../Doc/library/multiprocessing.rst:2419 msgid "**Examples**" msgstr "" #: ../Doc/library/multiprocessing.rst:2421 msgid "" "The following server code creates a listener which uses ``'secret " "password'`` as an authentication key. It then waits for a connection and " "sends some data to the client::" msgstr "" #: ../Doc/library/multiprocessing.rst:2440 msgid "" "The following code connects to the server and receives some data from the " "server::" msgstr "" #: ../Doc/library/multiprocessing.rst:2457 msgid "" "The following code uses :func:`~multiprocessing.connection.wait` to wait for " "messages from multiple processes at once::" msgstr "" #: ../Doc/library/multiprocessing.rst:2496 msgid "Address Formats" msgstr "" #: ../Doc/library/multiprocessing.rst:2498 msgid "" "An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where " "*hostname* is a string and *port* is an integer." msgstr "" #: ../Doc/library/multiprocessing.rst:2501 msgid "" "An ``'AF_UNIX'`` address is a string representing a filename on the " "filesystem." msgstr "" #: ../Doc/library/multiprocessing.rst:2507 msgid "An ``'AF_PIPE'`` address is a string of the form" msgstr "" #: ../Doc/library/multiprocessing.rst:2505 msgid "" ":samp:`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. To use :func:`Client` to " "connect to a named pipe on a remote computer called *ServerName* one should " "use an address of the form :samp:`r'\\\\\\\\{ServerName}\\\\pipe\\" "\\{PipeName}'` instead." msgstr "" #: ../Doc/library/multiprocessing.rst:2509 msgid "" "Note that any string beginning with two backslashes is assumed by default to " "be an ``'AF_PIPE'`` address rather than an ``'AF_UNIX'`` address." msgstr "" #: ../Doc/library/multiprocessing.rst:2516 msgid "Authentication keys" msgstr "" #: ../Doc/library/multiprocessing.rst:2518 msgid "" "When one uses :meth:`Connection.recv `, the data received " "is automatically unpickled. Unfortunately unpickling data from an untrusted " "source is a security risk. Therefore :class:`Listener` and :func:`Client` " "use the :mod:`hmac` module to provide digest authentication." msgstr "" #: ../Doc/library/multiprocessing.rst:2524 msgid "" "An authentication key is a byte string which can be thought of as a " "password: once a connection is established both ends will demand proof that " "the other knows the authentication key. (Demonstrating that both ends are " "using the same key does **not** involve sending the key over the connection.)" msgstr "" #: ../Doc/library/multiprocessing.rst:2530 msgid "" "If authentication is requested but no authentication key is specified then " "the return value of ``current_process().authkey`` is used (see :class:" "`~multiprocessing.Process`). This value will be automatically inherited by " "any :class:`~multiprocessing.Process` object that the current process " "creates. This means that (by default) all processes of a multi-process " "program will share a single authentication key which can be used when " "setting up connections between themselves." msgstr "" #: ../Doc/library/multiprocessing.rst:2538 msgid "" "Suitable authentication keys can also be generated by using :func:`os." "urandom`." msgstr "" #: ../Doc/library/multiprocessing.rst:2542 msgid "Logging" msgstr "Journalisation" #: ../Doc/library/multiprocessing.rst:2544 msgid "" "Some support for logging is available. Note, however, that the :mod:" "`logging` package does not use process shared locks so it is possible " "(depending on the handler type) for messages from different processes to get " "mixed up." msgstr "" #: ../Doc/library/multiprocessing.rst:2551 msgid "" "Returns the logger used by :mod:`multiprocessing`. If necessary, a new one " "will be created." msgstr "" #: ../Doc/library/multiprocessing.rst:2554 msgid "" "When first created the logger has level :data:`logging.NOTSET` and no " "default handler. Messages sent to this logger will not by default propagate " "to the root logger." msgstr "" #: ../Doc/library/multiprocessing.rst:2558 msgid "" "Note that on Windows child processes will only inherit the level of the " "parent process's logger -- any other customization of the logger will not be " "inherited." msgstr "" #: ../Doc/library/multiprocessing.rst:2565 msgid "" "This function performs a call to :func:`get_logger` but in addition to " "returning the logger created by get_logger, it adds a handler which sends " "output to :data:`sys.stderr` using format ``'[%(levelname)s/%(processName)s] " "%(message)s'``." msgstr "" #: ../Doc/library/multiprocessing.rst:2570 msgid "Below is an example session with logging turned on::" msgstr "" #: ../Doc/library/multiprocessing.rst:2585 msgid "For a full table of logging levels, see the :mod:`logging` module." msgstr "" #: ../Doc/library/multiprocessing.rst:2589 msgid "The :mod:`multiprocessing.dummy` module" msgstr "" #: ../Doc/library/multiprocessing.rst:2594 msgid "" ":mod:`multiprocessing.dummy` replicates the API of :mod:`multiprocessing` " "but is no more than a wrapper around the :mod:`threading` module." msgstr "" #: ../Doc/library/multiprocessing.rst:2601 msgid "Programming guidelines" msgstr "" #: ../Doc/library/multiprocessing.rst:2603 msgid "" "There are certain guidelines and idioms which should be adhered to when " "using :mod:`multiprocessing`." msgstr "" #: ../Doc/library/multiprocessing.rst:2608 msgid "All start methods" msgstr "" #: ../Doc/library/multiprocessing.rst:2610 msgid "The following applies to all start methods." msgstr "" #: ../Doc/library/multiprocessing.rst:2612 msgid "Avoid shared state" msgstr "" #: ../Doc/library/multiprocessing.rst:2614 msgid "" "As far as possible one should try to avoid shifting large amounts of data " "between processes." msgstr "" #: ../Doc/library/multiprocessing.rst:2617 msgid "" "It is probably best to stick to using queues or pipes for communication " "between processes rather than using the lower level synchronization " "primitives." msgstr "" #: ../Doc/library/multiprocessing.rst:2621 msgid "Picklability" msgstr "" #: ../Doc/library/multiprocessing.rst:2623 msgid "Ensure that the arguments to the methods of proxies are picklable." msgstr "" #: ../Doc/library/multiprocessing.rst:2625 msgid "Thread safety of proxies" msgstr "" #: ../Doc/library/multiprocessing.rst:2627 msgid "" "Do not use a proxy object from more than one thread unless you protect it " "with a lock." msgstr "" #: ../Doc/library/multiprocessing.rst:2630 msgid "" "(There is never a problem with different processes using the *same* proxy.)" msgstr "" #: ../Doc/library/multiprocessing.rst:2632 msgid "Joining zombie processes" msgstr "" #: ../Doc/library/multiprocessing.rst:2634 msgid "" "On Unix when a process finishes but has not been joined it becomes a zombie. " "There should never be very many because each time a new process starts (or :" "func:`~multiprocessing.active_children` is called) all completed processes " "which have not yet been joined will be joined. Also calling a finished " "process's :meth:`Process.is_alive ` will " "join the process. Even so it is probably good practice to explicitly join " "all the processes that you start." msgstr "" #: ../Doc/library/multiprocessing.rst:2642 msgid "Better to inherit than pickle/unpickle" msgstr "" #: ../Doc/library/multiprocessing.rst:2644 msgid "" "When using the *spawn* or *forkserver* start methods many types from :mod:" "`multiprocessing` need to be picklable so that child processes can use " "them. However, one should generally avoid sending shared objects to other " "processes using pipes or queues. Instead you should arrange the program so " "that a process which needs access to a shared resource created elsewhere can " "inherit it from an ancestor process." msgstr "" #: ../Doc/library/multiprocessing.rst:2652 msgid "Avoid terminating processes" msgstr "" #: ../Doc/library/multiprocessing.rst:2654 msgid "" "Using the :meth:`Process.terminate ` " "method to stop a process is liable to cause any shared resources (such as " "locks, semaphores, pipes and queues) currently being used by the process to " "become broken or unavailable to other processes." msgstr "" #: ../Doc/library/multiprocessing.rst:2660 msgid "" "Therefore it is probably best to only consider using :meth:`Process." "terminate ` on processes which never use " "any shared resources." msgstr "" #: ../Doc/library/multiprocessing.rst:2664 msgid "Joining processes that use queues" msgstr "" #: ../Doc/library/multiprocessing.rst:2666 msgid "" "Bear in mind that a process that has put items in a queue will wait before " "terminating until all the buffered items are fed by the \"feeder\" thread to " "the underlying pipe. (The child process can call the :meth:`Queue." "cancel_join_thread ` method of the " "queue to avoid this behaviour.)" msgstr "" #: ../Doc/library/multiprocessing.rst:2672 msgid "" "This means that whenever you use a queue you need to make sure that all " "items which have been put on the queue will eventually be removed before the " "process is joined. Otherwise you cannot be sure that processes which have " "put items on the queue will terminate. Remember also that non-daemonic " "processes will be joined automatically." msgstr "" #: ../Doc/library/multiprocessing.rst:2678 msgid "An example which will deadlock is the following::" msgstr "" #: ../Doc/library/multiprocessing.rst:2692 msgid "" "A fix here would be to swap the last two lines (or simply remove the ``p." "join()`` line)." msgstr "" #: ../Doc/library/multiprocessing.rst:2695 msgid "Explicitly pass resources to child processes" msgstr "" #: ../Doc/library/multiprocessing.rst:2697 msgid "" "On Unix using the *fork* start method, a child process can make use of a " "shared resource created in a parent process using a global resource. " "However, it is better to pass the object as an argument to the constructor " "for the child process." msgstr "" #: ../Doc/library/multiprocessing.rst:2702 msgid "" "Apart from making the code (potentially) compatible with Windows and the " "other start methods this also ensures that as long as the child process is " "still alive the object will not be garbage collected in the parent process. " "This might be important if some resource is freed when the object is garbage " "collected in the parent process." msgstr "" #: ../Doc/library/multiprocessing.rst:2709 msgid "So for instance ::" msgstr "" #: ../Doc/library/multiprocessing.rst:2721 msgid "should be rewritten as ::" msgstr "" #: ../Doc/library/multiprocessing.rst:2733 msgid "Beware of replacing :data:`sys.stdin` with a \"file like object\"" msgstr "" #: ../Doc/library/multiprocessing.rst:2735 msgid ":mod:`multiprocessing` originally unconditionally called::" msgstr "" #: ../Doc/library/multiprocessing.rst:2739 msgid "" "in the :meth:`multiprocessing.Process._bootstrap` method --- this resulted " "in issues with processes-in-processes. This has been changed to::" msgstr "" #: ../Doc/library/multiprocessing.rst:2745 msgid "" "Which solves the fundamental issue of processes colliding with each other " "resulting in a bad file descriptor error, but introduces a potential danger " "to applications which replace :func:`sys.stdin` with a \"file-like object\" " "with output buffering. This danger is that if multiple processes call :meth:" "`~io.IOBase.close()` on this file-like object, it could result in the same " "data being flushed to the object multiple times, resulting in corruption." msgstr "" #: ../Doc/library/multiprocessing.rst:2752 msgid "" "If you write a file-like object and implement your own caching, you can make " "it fork-safe by storing the pid whenever you append to the cache, and " "discarding the cache when the pid changes. For example::" msgstr "" #: ../Doc/library/multiprocessing.rst:2764 msgid "" "For more information, see :issue:`5155`, :issue:`5313` and :issue:`5331`" msgstr "" #: ../Doc/library/multiprocessing.rst:2767 msgid "The *spawn* and *forkserver* start methods" msgstr "" #: ../Doc/library/multiprocessing.rst:2769 msgid "" "There are a few extra restriction which don't apply to the *fork* start " "method." msgstr "" #: ../Doc/library/multiprocessing.rst:2772 msgid "More picklability" msgstr "" #: ../Doc/library/multiprocessing.rst:2774 msgid "" "Ensure that all arguments to :meth:`Process.__init__` are picklable. Also, " "if you subclass :class:`~multiprocessing.Process` then make sure that " "instances will be picklable when the :meth:`Process.start ` method is called." msgstr "" #: ../Doc/library/multiprocessing.rst:2779 msgid "Global variables" msgstr "" #: ../Doc/library/multiprocessing.rst:2781 msgid "" "Bear in mind that if code run in a child process tries to access a global " "variable, then the value it sees (if any) may not be the same as the value " "in the parent process at the time that :meth:`Process.start ` was called." msgstr "" #: ../Doc/library/multiprocessing.rst:2786 msgid "" "However, global variables which are just module level constants cause no " "problems." msgstr "" #: ../Doc/library/multiprocessing.rst:2789 msgid "Safe importing of main module" msgstr "" #: ../Doc/library/multiprocessing.rst:2791 msgid "" "Make sure that the main module can be safely imported by a new Python " "interpreter without causing unintended side effects (such a starting a new " "process)." msgstr "" #: ../Doc/library/multiprocessing.rst:2795 msgid "" "For example, using the *spawn* or *forkserver* start method running the " "following module would fail with a :exc:`RuntimeError`::" msgstr "" #: ../Doc/library/multiprocessing.rst:2807 msgid "" "Instead one should protect the \"entry point\" of the program by using ``if " "__name__ == '__main__':`` as follows::" msgstr "" #: ../Doc/library/multiprocessing.rst:2821 msgid "" "(The ``freeze_support()`` line can be omitted if the program will be run " "normally instead of frozen.)" msgstr "" #: ../Doc/library/multiprocessing.rst:2824 msgid "" "This allows the newly spawned Python interpreter to safely import the module " "and then run the module's ``foo()`` function." msgstr "" #: ../Doc/library/multiprocessing.rst:2827 msgid "" "Similar restrictions apply if a pool or manager is created in the main " "module." msgstr "" #: ../Doc/library/multiprocessing.rst:2834 msgid "Examples" msgstr "Exemples" #: ../Doc/library/multiprocessing.rst:2836 msgid "Demonstration of how to create and use customized managers and proxies:" msgstr "" #: ../Doc/library/multiprocessing.rst:2842 msgid "Using :class:`~multiprocessing.pool.Pool`:" msgstr "" #: ../Doc/library/multiprocessing.rst:2848 msgid "" "An example showing how to use queues to feed tasks to a collection of worker " "processes and collect the results:" msgstr ""