forked from AFPy/python-docs-fr
3097 lines
106 KiB
Plaintext
3097 lines
106 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
|
# Copyright (C) 2001-2016, Python Software Foundation
|
|
# This file is distributed under the same license as the Python package.
|
|
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
|
#
|
|
#, fuzzy
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Python 3.6\n"
|
|
"Report-Msgid-Bugs-To: \n"
|
|
"POT-Creation-Date: 2017-08-01 13:21+0200\n"
|
|
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
|
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
|
"Language-Team: LANGUAGE <LL@li.org>\n"
|
|
"Language: fr\n"
|
|
"MIME-Version: 1.0\n"
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
"Content-Transfer-Encoding: 8bit\n"
|
|
|
|
#: ../Doc/library/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 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 a 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:601
|
|
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:605
|
|
msgid "Example usage of some of the methods of :class:`Process`:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:625
|
|
msgid "The base class of all :mod:`multiprocessing` exceptions."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:629
|
|
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:632
|
|
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:637
|
|
msgid "Raised when there is an authentication error."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:641
|
|
msgid "Raised by methods with a timeout when the timeout expires."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:644
|
|
msgid "Pipes and Queues"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:646
|
|
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:650
|
|
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:653
|
|
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:660
|
|
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:665
|
|
msgid ""
|
|
"Note that one can also create a shared queue by using a manager object -- "
|
|
"see :ref:`multiprocessing-managers`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:670
|
|
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:677
|
|
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 <multiprocessing-managers>`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:684
|
|
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:689
|
|
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:696
|
|
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:703
|
|
msgid ""
|
|
"As mentioned above, if a child process has put items on a queue (and it has "
|
|
"not used :meth:`JoinableQueue.cancel_join_thread <multiprocessing.Queue."
|
|
"cancel_join_thread>`), then that process will not terminate until all "
|
|
"buffered items have been flushed to the pipe."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:708
|
|
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:713
|
|
msgid ""
|
|
"Note that a queue created using a manager does not have this issue. See :"
|
|
"ref:`multiprocessing-programming`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:716
|
|
msgid ""
|
|
"For an example of the usage of queues for interprocess communication see :"
|
|
"ref:`multiprocessing-examples`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:722
|
|
msgid ""
|
|
"Returns a pair ``(conn1, conn2)`` of :class:`Connection` objects "
|
|
"representing the ends of a pipe."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:725
|
|
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:733
|
|
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:737
|
|
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:740
|
|
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:745
|
|
msgid ""
|
|
"Return the approximate size of the queue. Because of multithreading/"
|
|
"multiprocessing semantics, this number is not reliable."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:748
|
|
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:753
|
|
msgid ""
|
|
"Return ``True`` if the queue is empty, ``False`` otherwise. Because of "
|
|
"multithreading/multiprocessing semantics, this is not reliable."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:758
|
|
msgid ""
|
|
"Return ``True`` if the queue is full, ``False`` otherwise. Because of "
|
|
"multithreading/multiprocessing semantics, this is not reliable."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:763
|
|
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:774
|
|
msgid "Equivalent to ``put(obj, False)``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:778
|
|
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:788
|
|
msgid "Equivalent to ``get(False)``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:790
|
|
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:796
|
|
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:803
|
|
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:807
|
|
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:813
|
|
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:817
|
|
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:826
|
|
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:835
|
|
msgid ""
|
|
"It is a simplified :class:`Queue` type, very close to a locked :class:`Pipe`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:839
|
|
msgid "Return ``True`` if the queue is empty, ``False`` otherwise."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:843
|
|
msgid "Remove and return an item from the queue."
|
|
msgstr "Supprime et donne un élément de la queue."
|
|
|
|
#: ../Doc/library/multiprocessing.rst:847
|
|
msgid "Put *item* into the queue."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:852
|
|
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:857
|
|
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:862
|
|
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:866
|
|
msgid ""
|
|
"Raises a :exc:`ValueError` if called more times than there were items placed "
|
|
"in the queue."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:872
|
|
msgid "Block until all items in the queue have been gotten and processed."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:874
|
|
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:882
|
|
msgid "Miscellaneous"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:886
|
|
msgid "Return list of all live children of the current process."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:888
|
|
msgid ""
|
|
"Calling this has the side effect of \"joining\" any processes which have "
|
|
"already finished."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:893
|
|
msgid "Return the number of CPUs in the system."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:895
|
|
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 ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:899
|
|
msgid "May raise :exc:`NotImplementedError`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:902
|
|
msgid ":func:`os.cpu_count`"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:906
|
|
msgid ""
|
|
"Return the :class:`Process` object corresponding to the current process."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:908
|
|
msgid "An analogue of :func:`threading.current_thread`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:912
|
|
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:916
|
|
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:928
|
|
msgid ""
|
|
"If the ``freeze_support()`` line is omitted then trying to run the frozen "
|
|
"executable will raise :exc:`RuntimeError`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:931
|
|
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:938
|
|
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:948
|
|
msgid ""
|
|
"Return a context object which has the same attributes as the :mod:"
|
|
"`multiprocessing` module."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:951
|
|
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:960
|
|
msgid "Return the name of start method used for starting processes."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:962
|
|
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:967
|
|
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:975
|
|
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:981
|
|
msgid "before they can create child processes."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:983
|
|
msgid "Now supported on Unix when the ``'spawn'`` start method is used."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:988
|
|
msgid ""
|
|
"Set the method which should be used to start child processes. *method* can "
|
|
"be ``'fork'``, ``'spawn'`` or ``'forkserver'``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:991
|
|
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:999
|
|
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:1006
|
|
msgid "Connection Objects"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1008
|
|
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:1011
|
|
msgid ""
|
|
"Connection objects are usually created using :func:`Pipe` -- see also :ref:"
|
|
"`multiprocessing-listeners-clients`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1018
|
|
msgid ""
|
|
"Send an object to the other end of the connection which should be read "
|
|
"using :meth:`recv`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1021
|
|
msgid ""
|
|
"The object must be picklable. Very large pickles (approximately 32 MB+, "
|
|
"though it depends on the OS) may raise a :exc:`ValueError` exception."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1026
|
|
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:1033
|
|
msgid "Return the file descriptor or handle used by the connection."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1037
|
|
msgid "Close the connection."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1039
|
|
msgid "This is called automatically when the connection is garbage collected."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1043
|
|
msgid "Return whether there is any data available to be read."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1045
|
|
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:1049
|
|
msgid ""
|
|
"Note that multiple connection objects may be polled at once by using :func:"
|
|
"`multiprocessing.connection.wait`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1054
|
|
msgid "Send byte data from a :term:`bytes-like object` as a complete message."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1056
|
|
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 MB+, though it depends on the OS) may raise a :exc:"
|
|
"`ValueError` exception"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1063
|
|
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:1068
|
|
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:1072
|
|
msgid ""
|
|
"This function used to raise :exc:`IOError`, which is now an alias of :exc:"
|
|
"`OSError`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1079
|
|
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:1085
|
|
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:1090
|
|
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:1094
|
|
msgid ""
|
|
"Connection objects themselves can now be transferred between processes "
|
|
"using :meth:`Connection.send` and :meth:`Connection.recv`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1098
|
|
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:1103
|
|
msgid "For example:"
|
|
msgstr "Par exemple : ::"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1127
|
|
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:1131
|
|
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:1138
|
|
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:1144
|
|
msgid "Synchronization primitives"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1146
|
|
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:1150
|
|
msgid ""
|
|
"Note that one can also create synchronization primitives by using a manager "
|
|
"object -- see :ref:`multiprocessing-managers`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1155
|
|
msgid "A barrier object: a clone of :class:`threading.Barrier`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1161
|
|
msgid ""
|
|
"A bounded semaphore object: a close analog of :class:`threading."
|
|
"BoundedSemaphore`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1164
|
|
#: ../Doc/library/multiprocessing.rst:1302
|
|
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:1168
|
|
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:1173
|
|
msgid "A condition variable: an alias for :class:`threading.Condition`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1175
|
|
msgid ""
|
|
"If *lock* is specified then it should be a :class:`Lock` or :class:`RLock` "
|
|
"object from :mod:`multiprocessing`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1178
|
|
#: ../Doc/library/multiprocessing.rst:1712
|
|
msgid "The :meth:`~threading.Condition.wait_for` method was added."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1183
|
|
msgid "A clone of :class:`threading.Event`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1188
|
|
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:1196
|
|
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:1200
|
|
msgid ""
|
|
":class:`Lock` supports the :term:`context manager` protocol and thus may be "
|
|
"used in :keyword:`with` statements."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1205
|
|
#: ../Doc/library/multiprocessing.rst:1256
|
|
msgid "Acquire a lock, blocking or non-blocking."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1207
|
|
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:1212
|
|
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:1216
|
|
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:1231
|
|
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:1234
|
|
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:1240
|
|
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:1246
|
|
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:1250
|
|
msgid ""
|
|
":class:`RLock` supports the :term:`context manager` protocol and thus may be "
|
|
"used in :keyword:`with` statements."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1258
|
|
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:1268
|
|
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:1276
|
|
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:1283
|
|
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:1291
|
|
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:1300
|
|
msgid "A semaphore object: a close analog of :class:`threading.Semaphore`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1307
|
|
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:1312
|
|
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:1318
|
|
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:1323
|
|
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:1331
|
|
msgid "Shared :mod:`ctypes` Objects"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1333
|
|
msgid ""
|
|
"It is possible to create shared objects using shared memory which can be "
|
|
"inherited by child processes."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1338
|
|
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:1342
|
|
#: ../Doc/library/multiprocessing.rst:1429
|
|
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:1346
|
|
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:1353
|
|
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:1359
|
|
msgid ""
|
|
"Assuming the associated lock is recursive (which it is by default) you can "
|
|
"instead do ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1365
|
|
#: ../Doc/library/multiprocessing.rst:1455
|
|
#: ../Doc/library/multiprocessing.rst:1470
|
|
msgid "Note that *lock* is a keyword-only argument."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1369
|
|
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:1372
|
|
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:1379
|
|
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:1386
|
|
msgid "Note that *lock* is a keyword only argument."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1388
|
|
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:1393
|
|
msgid "The :mod:`multiprocessing.sharedctypes` module"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1398
|
|
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:1404
|
|
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:1412
|
|
msgid "Return a ctypes array allocated from shared memory."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1414
|
|
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:1421
|
|
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:1427
|
|
msgid "Return a ctypes object allocated from shared memory."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1433
|
|
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:1437
|
|
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:1443
|
|
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:1447
|
|
#: ../Doc/library/multiprocessing.rst:1463
|
|
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:1459
|
|
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:1474
|
|
msgid ""
|
|
"Return a ctypes object allocated from shared memory which is a copy of the "
|
|
"ctypes object *obj*."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1479
|
|
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:1483
|
|
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:1487
|
|
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:1490
|
|
msgid "Synchronized objects support the :term:`context manager` protocol."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1494
|
|
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:1499
|
|
msgid "ctypes"
|
|
msgstr "ctypes"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1499
|
|
msgid "sharedctypes using type"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1499
|
|
msgid "sharedctypes using typecode"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1501
|
|
msgid "c_double(2.4)"
|
|
msgstr "c_double(2.4)"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1501
|
|
msgid "RawValue(c_double, 2.4)"
|
|
msgstr "RawValue(c_double, 2.4)"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1501
|
|
msgid "RawValue('d', 2.4)"
|
|
msgstr "RawValue('d', 2.4)"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1502
|
|
msgid "MyStruct(4, 6)"
|
|
msgstr "MyStruct(4, 6)"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1502
|
|
msgid "RawValue(MyStruct, 4, 6)"
|
|
msgstr "RawValue(MyStruct, 4, 6)"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1503
|
|
msgid "(c_short * 7)()"
|
|
msgstr "(c_short * 7)()"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1503
|
|
msgid "RawArray(c_short, 7)"
|
|
msgstr "RawArray(c_short, 7)"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1503
|
|
msgid "RawArray('h', 7)"
|
|
msgstr "RawArray('h', 7)"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1504
|
|
msgid "(c_int * 3)(9, 2, 8)"
|
|
msgstr "(c_int * 3)(9, 2, 8)"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1504
|
|
msgid "RawArray(c_int, (9, 2, 8))"
|
|
msgstr "RawArray(c_int, (9, 2, 8))"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1504
|
|
msgid "RawArray('i', (9, 2, 8))"
|
|
msgstr "RawArray('i', (9, 2, 8))"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1508
|
|
msgid ""
|
|
"Below is an example where a number of ctypes objects are modified by a child "
|
|
"process::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1546
|
|
msgid "The results printed are ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1559
|
|
msgid "Managers"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1561
|
|
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:1569
|
|
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:1577
|
|
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:1583
|
|
msgid "Create a BaseManager object."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1585
|
|
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:1588
|
|
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:1591
|
|
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:1598
|
|
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:1603
|
|
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:1612
|
|
msgid ":class:`Server` additionally has an :attr:`address` attribute."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1616
|
|
msgid "Connect a local manager object to a remote manager process::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1624
|
|
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:1627
|
|
msgid "This can be called multiple times."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1631
|
|
msgid ""
|
|
"A classmethod which can be used for registering a type or callable with the "
|
|
"manager class."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1634
|
|
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:1637
|
|
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:1643
|
|
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:1647
|
|
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:1656
|
|
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:1663
|
|
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:1667
|
|
msgid ":class:`BaseManager` instances also have one read-only property:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1671
|
|
msgid "The address used by the manager."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1673
|
|
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:1679
|
|
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:1684
|
|
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:1688
|
|
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:1694
|
|
msgid ""
|
|
"Create a shared :class:`threading.Barrier` object and return a proxy for it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1701
|
|
msgid ""
|
|
"Create a shared :class:`threading.BoundedSemaphore` object and return a "
|
|
"proxy for it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1706
|
|
msgid ""
|
|
"Create a shared :class:`threading.Condition` object and return a proxy for "
|
|
"it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1709
|
|
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:1717
|
|
msgid ""
|
|
"Create a shared :class:`threading.Event` object and return a proxy for it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1721
|
|
msgid ""
|
|
"Create a shared :class:`threading.Lock` object and return a proxy for it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1725
|
|
msgid "Create a shared :class:`Namespace` object and return a proxy for it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1729
|
|
msgid "Create a shared :class:`queue.Queue` object and return a proxy for it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1733
|
|
msgid ""
|
|
"Create a shared :class:`threading.RLock` object and return a proxy for it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1737
|
|
msgid ""
|
|
"Create a shared :class:`threading.Semaphore` object and return a proxy for "
|
|
"it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1742
|
|
msgid "Create an array and return a proxy for it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1746
|
|
msgid ""
|
|
"Create an object with a writable ``value`` attribute and return a proxy for "
|
|
"it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1753
|
|
msgid "Create a shared :class:`dict` object and return a proxy for it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1758
|
|
msgid "Create a shared :class:`list` object and return a proxy for it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1760
|
|
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:1767
|
|
msgid "A type that can register with :class:`SyncManager`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1769
|
|
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:1772
|
|
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:1788
|
|
msgid "Customized managers"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1790
|
|
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:1815
|
|
msgid "Using a remote manager"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1817
|
|
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:1820
|
|
msgid ""
|
|
"Running the following commands creates a server for a single shared queue "
|
|
"which remote clients can access::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1832
|
|
msgid "One client can access the server as follows::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1842
|
|
msgid "Another client can also use it::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1853
|
|
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:1878
|
|
msgid "Proxy Objects"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1880
|
|
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:1884
|
|
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:1902
|
|
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:1906
|
|
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:1922
|
|
msgid "Similarly, dict and list proxies may be nested inside one another::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1935
|
|
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:1954
|
|
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:1960
|
|
msgid ""
|
|
"The proxy types in :mod:`multiprocessing` do nothing to support comparisons "
|
|
"by value. So, for instance, we have:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1968
|
|
msgid ""
|
|
"One should just use a copy of the referent instead when making comparisons."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1972
|
|
msgid "Proxy objects are instances of subclasses of :class:`BaseProxy`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1976
|
|
msgid "Call and return the result of a method of the proxy's referent."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1978
|
|
msgid ""
|
|
"If ``proxy`` is a proxy whose referent is ``obj`` then the expression ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1982
|
|
msgid "will evaluate the expression ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1986
|
|
msgid "in the manager's process."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:1988
|
|
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:1992
|
|
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:1997
|
|
msgid ""
|
|
"Note in particular that an exception will be raised if *methodname* has not "
|
|
"been *exposed*."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2000
|
|
msgid "An example of the usage of :meth:`_callmethod`:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2016
|
|
msgid "Return a copy of the referent."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2018
|
|
msgid "If the referent is unpicklable then this will raise an exception."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2022
|
|
msgid "Return a representation of the proxy object."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2026
|
|
msgid "Return the representation of the referent."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2030
|
|
msgid "Cleanup"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2032
|
|
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:2035
|
|
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:2040
|
|
msgid "Process Pools"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2045
|
|
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:2050
|
|
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:2054
|
|
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:2057
|
|
msgid ""
|
|
"If *initializer* is not ``None`` then each worker process will call "
|
|
"``initializer(*initargs)`` when it starts."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2060
|
|
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:2065
|
|
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:2071
|
|
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:2074
|
|
msgid "*maxtasksperchild*"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2077
|
|
msgid "*context*"
|
|
msgstr "*context*"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2082
|
|
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:2092
|
|
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:2099
|
|
msgid "A variant of the :meth:`apply` method which returns a result object."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2101
|
|
#: ../Doc/library/multiprocessing.rst:2126
|
|
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:2106
|
|
#: ../Doc/library/multiprocessing.rst:2131
|
|
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:2110
|
|
#: ../Doc/library/multiprocessing.rst:2135
|
|
msgid ""
|
|
"Callbacks should complete immediately since otherwise the thread which "
|
|
"handles the results will get blocked."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2115
|
|
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:2118
|
|
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:2124
|
|
msgid "A variant of the :meth:`.map` method which returns a result object."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2140
|
|
msgid "A lazier version of :meth:`map`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2142
|
|
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:2147
|
|
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:2154
|
|
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:2160
|
|
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:2163
|
|
msgid ""
|
|
"Hence an *iterable* of ``[(1,2), (3, 4)]`` results in ``[func(1,2), "
|
|
"func(3,4)]``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2170
|
|
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:2178
|
|
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:2183
|
|
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:2189
|
|
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:2192
|
|
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:2200
|
|
msgid ""
|
|
"The class of the result returned by :meth:`Pool.apply_async` and :meth:`Pool."
|
|
"map_async`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2205
|
|
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:2212
|
|
msgid "Wait until the result is available or until *timeout* seconds pass."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2216
|
|
msgid "Return whether the call has completed."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2220
|
|
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:2223
|
|
msgid "The following example demonstrates the use of a pool::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2250
|
|
msgid "Listeners and Clients"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2255
|
|
msgid ""
|
|
"Usually message passing between processes is done using queues or by using :"
|
|
"class:`~multiprocessing.Connection` objects returned by :func:"
|
|
"`~multiprocessing.Pipe`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2259
|
|
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:2268
|
|
msgid ""
|
|
"Send a randomly generated message to the other end of the connection and "
|
|
"wait for a reply."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2271
|
|
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:2277
|
|
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:2280
|
|
msgid ""
|
|
"If a welcome message is not received, then :exc:`~multiprocessing."
|
|
"AuthenticationError` is raised."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2285
|
|
msgid ""
|
|
"Attempt to set up a connection to the listener which is using address "
|
|
"*address*, returning a :class:`~multiprocessing.Connection`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2288
|
|
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:2292
|
|
msgid ""
|
|
"If *authenticate* is ``True`` or *authkey* is a byte string then digest "
|
|
"authentication is used. The key used for authentication will be either "
|
|
"*authkey* or ``current_process().authkey`` if *authkey* is ``None``. If "
|
|
"authentication fails then :exc:`~multiprocessing.AuthenticationError` is "
|
|
"raised. See :ref:`multiprocessing-auth-keys`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2301
|
|
msgid ""
|
|
"A wrapper for a bound socket or Windows named pipe which is 'listening' for "
|
|
"connections."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2304
|
|
msgid ""
|
|
"*address* is the address to be used by the bound socket or named pipe of the "
|
|
"listener object."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2309
|
|
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:2313
|
|
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:2324
|
|
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:2328
|
|
msgid ""
|
|
"If *authenticate* is ``True`` (``False`` by default) or *authkey* is not "
|
|
"``None`` then digest authentication is used."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2331
|
|
msgid ""
|
|
"If *authkey* is a byte string then it will be used as the authentication "
|
|
"key; otherwise it must be ``None``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2334
|
|
msgid ""
|
|
"If *authkey* is ``None`` and *authenticate* is ``True`` then "
|
|
"``current_process().authkey`` is used as the authentication key. If "
|
|
"*authkey* is ``None`` and *authenticate* is ``False`` then no authentication "
|
|
"is done. If authentication fails then :exc:`~multiprocessing."
|
|
"AuthenticationError` is raised. See :ref:`multiprocessing-auth-keys`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2343
|
|
msgid ""
|
|
"Accept a connection on the bound socket or named pipe of the listener object "
|
|
"and return a :class:`~multiprocessing.Connection` object. If authentication "
|
|
"is attempted and fails, then :exc:`~multiprocessing.AuthenticationError` is "
|
|
"raised."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2350
|
|
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:2354
|
|
msgid "Listener objects have the following read-only properties:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2358
|
|
msgid "The address which is being used by the Listener object."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2362
|
|
msgid ""
|
|
"The address from which the last accepted connection came. If this is "
|
|
"unavailable then it is ``None``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2365
|
|
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:2372
|
|
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:2378
|
|
msgid ""
|
|
"For both Unix and Windows, an object can appear in *object_list* if it is"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2381
|
|
msgid "a readable :class:`~multiprocessing.Connection` object;"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2382
|
|
msgid "a connected and readable :class:`socket.socket` object; or"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2383
|
|
msgid ""
|
|
"the :attr:`~multiprocessing.Process.sentinel` attribute of a :class:"
|
|
"`~multiprocessing.Process` object."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2386
|
|
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:2389
|
|
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:2395
|
|
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:2405
|
|
msgid "**Examples**"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2407
|
|
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:2426
|
|
msgid ""
|
|
"The following code connects to the server and receives some data from the "
|
|
"server::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2443
|
|
msgid ""
|
|
"The following code uses :func:`~multiprocessing.connection.wait` to wait for "
|
|
"messages from multiple processes at once::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2482
|
|
msgid "Address Formats"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2484
|
|
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:2487
|
|
msgid ""
|
|
"An ``'AF_UNIX'`` address is a string representing a filename on the "
|
|
"filesystem."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2493
|
|
msgid "An ``'AF_PIPE'`` address is a string of the form"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2491
|
|
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:2495
|
|
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:2502
|
|
msgid "Authentication keys"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2504
|
|
msgid ""
|
|
"When one uses :meth:`Connection.recv <multiprocessing.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:2510
|
|
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:2516
|
|
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:2524
|
|
msgid ""
|
|
"Suitable authentication keys can also be generated by using :func:`os."
|
|
"urandom`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2528
|
|
msgid "Logging"
|
|
msgstr "Journalisation"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2530
|
|
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:2537
|
|
msgid ""
|
|
"Returns the logger used by :mod:`multiprocessing`. If necessary, a new one "
|
|
"will be created."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2540
|
|
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:2544
|
|
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:2551
|
|
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:2556
|
|
msgid "Below is an example session with logging turned on::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2571
|
|
msgid "For a full table of logging levels, see the :mod:`logging` module."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2575
|
|
msgid "The :mod:`multiprocessing.dummy` module"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2580
|
|
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:2587
|
|
msgid "Programming guidelines"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2589
|
|
msgid ""
|
|
"There are certain guidelines and idioms which should be adhered to when "
|
|
"using :mod:`multiprocessing`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2594
|
|
msgid "All start methods"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2596
|
|
msgid "The following applies to all start methods."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2598
|
|
msgid "Avoid shared state"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2600
|
|
msgid ""
|
|
"As far as possible one should try to avoid shifting large amounts of data "
|
|
"between processes."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2603
|
|
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:2607
|
|
msgid "Picklability"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2609
|
|
msgid "Ensure that the arguments to the methods of proxies are picklable."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2611
|
|
msgid "Thread safety of proxies"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2613
|
|
msgid ""
|
|
"Do not use a proxy object from more than one thread unless you protect it "
|
|
"with a lock."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2616
|
|
msgid ""
|
|
"(There is never a problem with different processes using the *same* proxy.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2618
|
|
msgid "Joining zombie processes"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2620
|
|
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 <multiprocessing.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:2628
|
|
msgid "Better to inherit than pickle/unpickle"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2630
|
|
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:2638
|
|
msgid "Avoid terminating processes"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2640
|
|
msgid ""
|
|
"Using the :meth:`Process.terminate <multiprocessing.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:2646
|
|
msgid ""
|
|
"Therefore it is probably best to only consider using :meth:`Process."
|
|
"terminate <multiprocessing.Process.terminate>` on processes which never use "
|
|
"any shared resources."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2650
|
|
msgid "Joining processes that use queues"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2652
|
|
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 <multiprocessing.Queue.cancel_join_thread>` method of the "
|
|
"queue to avoid this behaviour.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2658
|
|
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:2664
|
|
msgid "An example which will deadlock is the following::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2678
|
|
msgid ""
|
|
"A fix here would be to swap the last two lines (or simply remove the ``p."
|
|
"join()`` line)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2681
|
|
msgid "Explicitly pass resources to child processes"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2683
|
|
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:2688
|
|
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:2695
|
|
msgid "So for instance ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2707
|
|
msgid "should be rewritten as ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2719
|
|
msgid "Beware of replacing :data:`sys.stdin` with a \"file like object\""
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2721
|
|
msgid ":mod:`multiprocessing` originally unconditionally called::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2725
|
|
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:2731
|
|
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:2738
|
|
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:2750
|
|
msgid ""
|
|
"For more information, see :issue:`5155`, :issue:`5313` and :issue:`5331`"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2753
|
|
msgid "The *spawn* and *forkserver* start methods"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2755
|
|
msgid ""
|
|
"There are a few extra restriction which don't apply to the *fork* start "
|
|
"method."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2758
|
|
msgid "More picklability"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2760
|
|
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 <multiprocessing."
|
|
"Process.start>` method is called."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2765
|
|
msgid "Global variables"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2767
|
|
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 <multiprocessing."
|
|
"Process.start>` was called."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2772
|
|
msgid ""
|
|
"However, global variables which are just module level constants cause no "
|
|
"problems."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2775
|
|
msgid "Safe importing of main module"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2777
|
|
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:2781
|
|
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:2793
|
|
msgid ""
|
|
"Instead one should protect the \"entry point\" of the program by using ``if "
|
|
"__name__ == '__main__':`` as follows::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2807
|
|
msgid ""
|
|
"(The ``freeze_support()`` line can be omitted if the program will be run "
|
|
"normally instead of frozen.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2810
|
|
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:2813
|
|
msgid ""
|
|
"Similar restrictions apply if a pool or manager is created in the main "
|
|
"module."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2820
|
|
msgid "Examples"
|
|
msgstr "Exemples"
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2822
|
|
msgid "Demonstration of how to create and use customized managers and proxies:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2828
|
|
msgid "Using :class:`~multiprocessing.pool.Pool`:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/multiprocessing.rst:2834
|
|
msgid ""
|
|
"An example showing how to use queues to feed tasks to a collection of worker "
|
|
"processes and collect the results:"
|
|
msgstr ""
|