multiprocessing.po

# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-04-20 00:26+0000\n"
"PO-Revision-Date: 2018-05-23 16:06+0000\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/multiprocessing.rst:2
msgid ":mod:`!multiprocessing` --- Process-based parallelism"
msgstr ":mod:`!multiprocessing` --- 以行程為基礎的平行性"

#: ../../library/multiprocessing.rst:7
msgid "**Source code:** :source:`Lib/multiprocessing/`"
msgstr "**原始碼：**\\ :source:`Lib/multiprocessing/`"

#: ../../includes/wasm-mobile-notavail.rst:3
msgid "Availability"
msgstr "可用性"

#: ../../includes/wasm-mobile-notavail.rst:5
msgid ""
"This module is not supported on :ref:`mobile platforms <mobile-"
"availability>` or :ref:`WebAssembly platforms <wasm-availability>`."
msgstr ""
"此模組在\\ :ref:`行動平台 <mobile-availability>`\\ 或 :ref:`WebAssembly 平台 "
"<wasm-availability>`\\ 上不支援。"

#: ../../library/multiprocessing.rst:14
msgid "Introduction"
msgstr "簡介"

#: ../../library/multiprocessing.rst:16
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 <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 POSIX and Windows."
msgstr ""

#: ../../library/multiprocessing.rst:25
msgid ""
"The :mod:`!multiprocessing` module also introduces 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 ""

#: ../../library/multiprocessing.rst:33
msgid ""
"from multiprocessing import Pool\n"
"\n"
"def f(x):\n"
"    return x*x\n"
"\n"
"if __name__ == '__main__':\n"
"    with Pool(5) as p:\n"
"        print(p.map(f, [1, 2, 3]))"
msgstr ""
"from multiprocessing import Pool\n"
"\n"
"def f(x):\n"
"    return x*x\n"
"\n"
"if __name__ == '__main__':\n"
"    with Pool(5) as p:\n"
"        print(p.map(f, [1, 2, 3]))"

#: ../../library/multiprocessing.rst:42
msgid "will print to standard output ::"
msgstr ""

#: ../../library/multiprocessing.rst:44
msgid "[1, 4, 9]"
msgstr "[1, 4, 9]"

#: ../../library/multiprocessing.rst:46
msgid ""
"The :mod:`!multiprocessing` module also introduces APIs which do not have "
"analogs in the :mod:`threading` module, like the ability to :meth:`terminate "
"<Process.terminate>`, :meth:`interrupt <Process.interrupt>` or :meth:`kill "
"<Process.kill>` a running process."
msgstr ""

#: ../../library/multiprocessing.rst:53
msgid ""
":class:`concurrent.futures.ProcessPoolExecutor` offers a higher level "
"interface to push tasks to a background process without blocking execution "
"of the calling process. Compared to using the :class:`~multiprocessing.pool."
"Pool` interface directly, the :mod:`concurrent.futures` API more readily "
"allows the submission of work to the underlying process pool to be separated "
"from waiting for the results."
msgstr ""

#: ../../library/multiprocessing.rst:62
msgid "The :class:`Process` class"
msgstr ":class:`Process` 類別"

#: ../../library/multiprocessing.rst:64
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 ""

#: ../../library/multiprocessing.rst:69
msgid ""
"from multiprocessing import Process\n"
"\n"
"def f(name):\n"
"    print('hello', name)\n"
"\n"
"if __name__ == '__main__':\n"
"    p = Process(target=f, args=('bob',))\n"
"    p.start()\n"
"    p.join()"
msgstr ""
"from multiprocessing import Process\n"
"\n"
"def f(name):\n"
"    print('hello', name)\n"
"\n"
"if __name__ == '__main__':\n"
"    p = Process(target=f, args=('bob',))\n"
"    p.start()\n"
"    p.join()"

#: ../../library/multiprocessing.rst:79
msgid ""
"To show the individual process IDs involved, here is an expanded example::"
msgstr ""

#: ../../library/multiprocessing.rst:81
msgid ""
"from multiprocessing import Process\n"
"import os\n"
"\n"
"def info(title):\n"
"    print(title)\n"
"    print('module name:', __name__)\n"
"    print('parent process:', os.getppid())\n"
"    print('process id:', os.getpid())\n"
"\n"
"def f(name):\n"
"    info('function f')\n"
"    print('hello', name)\n"
"\n"
"if __name__ == '__main__':\n"
"    info('main line')\n"
"    p = Process(target=f, args=('bob',))\n"
"    p.start()\n"
"    p.join()"
msgstr ""
"from multiprocessing import Process\n"
"import os\n"
"\n"
"def info(title):\n"
"    print(title)\n"
"    print('module name:', __name__)\n"
"    print('parent process:', os.getppid())\n"
"    print('process id:', os.getpid())\n"
"\n"
"def f(name):\n"
"    info('function f')\n"
"    print('hello', name)\n"
"\n"
"if __name__ == '__main__':\n"
"    info('main line')\n"
"    p = Process(target=f, args=('bob',))\n"
"    p.start()\n"
"    p.join()"

#: ../../library/multiprocessing.rst:100
msgid ""
"For an explanation of why the ``if __name__ == '__main__'`` part is "
"necessary, see :ref:`multiprocessing-programming`."
msgstr ""

#: ../../library/multiprocessing.rst:103
msgid ""
"The arguments to :class:`Process` usually need to be unpickleable from "
"within the child process. If you tried typing the above example directly "
"into a REPL it could lead to an :exc:`AttributeError` in the child process "
"trying to locate the *f* function in the ``__main__`` module."
msgstr ""

#: ../../library/multiprocessing.rst:112
msgid "Contexts and start methods"
msgstr ""

#: ../../library/multiprocessing.rst:114
msgid ""
"Depending on the platform, :mod:`!multiprocessing` supports three ways to "
"start a process.  These *start methods* are"
msgstr ""

#: ../../library/multiprocessing.rst:119
msgid "*spawn*"
msgstr "*spawn*"

#: ../../library/multiprocessing.rst:120
msgid ""
"The parent process starts a fresh Python interpreter process.  The child "
"process will only inherit those resources necessary to run the process "
"object's :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 ""

#: ../../library/multiprocessing.rst:127
msgid ""
"Available on POSIX and Windows platforms.  The default on Windows and macOS."
msgstr ""

#: ../../library/multiprocessing.rst:131
msgid "*fork*"
msgstr "*fork*"

#: ../../library/multiprocessing.rst:132
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 ""

#: ../../library/multiprocessing.rst:138
msgid "Available on POSIX systems."
msgstr ""

#: ../../library/multiprocessing.rst:140
msgid ""
"This is no longer the default start method on any platform. Code that "
"requires *fork* must explicitly specify that via :func:`get_context` or :"
"func:`set_start_method`."
msgstr ""

#: ../../library/multiprocessing.rst:145
msgid ""
"If Python is able to detect that your process has multiple threads, the :"
"func:`os.fork` function that this start method calls internally will raise "
"a :exc:`DeprecationWarning`. Use a different start method. See the :func:`os."
"fork` documentation for further explanation."
msgstr ""

#: ../../library/multiprocessing.rst:153
msgid "*forkserver*"
msgstr "*forkserver*"

#: ../../library/multiprocessing.rst:154
msgid ""
"When the program starts and selects the *forkserver* start method, a server "
"process is spawned.  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 unless system libraries "
"or preloaded imports spawn threads as a side-effect so it is generally safe "
"for it to use :func:`os.fork`. No unnecessary resources are inherited."
msgstr ""

#: ../../library/multiprocessing.rst:162
msgid ""
"Available on POSIX platforms which support passing file descriptors over "
"Unix pipes such as Linux.  The default on those."
msgstr ""

#: ../../library/multiprocessing.rst:165
msgid "This became the default start method on POSIX platforms."
msgstr ""

#: ../../library/multiprocessing.rst:168
msgid ""
"*spawn* added on all POSIX platforms, and *forkserver* added for some POSIX "
"platforms. Child processes no longer inherit all of the parents inheritable "
"handles on Windows."
msgstr ""

#: ../../library/multiprocessing.rst:176
msgid ""
"On macOS, the *spawn* start method is now the default.  The *fork* start "
"method should be considered unsafe as it can lead to crashes of the "
"subprocess as macOS system libraries may start threads. See :issue:`33725`."
msgstr ""

#: ../../library/multiprocessing.rst:182
msgid ""
"On POSIX platforms the default start method was changed from *fork* to "
"*forkserver* to retain the performance but avoid common multithreaded "
"process incompatibilities. See :gh:`84559`."
msgstr ""

#: ../../library/multiprocessing.rst:187
msgid ""
"On POSIX using the *spawn* or *forkserver* start methods will also start a "
"*resource tracker* process which tracks the unlinked named system resources "
"(such as named semaphores or :class:`~multiprocessing.shared_memory."
"SharedMemory` objects) created by processes of the program.  When all "
"processes have exited the resource tracker unlinks any remaining tracked "
"object. Usually there should be none, but if a process was killed by a "
"signal there may be some \"leaked\" resources.  (Neither leaked semaphores "
"nor shared memory segments will be automatically unlinked until the next "
"reboot. This is problematic for both objects because the system allows only "
"a limited number of named semaphores, and shared memory segments occupy some "
"space in the main memory.)"
msgstr ""

#: ../../library/multiprocessing.rst:200
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 ""

#: ../../library/multiprocessing.rst:204
msgid ""
"import multiprocessing as mp\n"
"\n"
"def foo(q):\n"
"    q.put('hello')\n"
"\n"
"if __name__ == '__main__':\n"
"    mp.set_start_method('spawn')\n"
"    q = mp.Queue()\n"
"    p = mp.Process(target=foo, args=(q,))\n"
"    p.start()\n"
"    print(q.get())\n"
"    p.join()"
msgstr ""
"import multiprocessing as mp\n"
"\n"
"def foo(q):\n"
"    q.put('hello')\n"
"\n"
"if __name__ == '__main__':\n"
"    mp.set_start_method('spawn')\n"
"    q = mp.Queue()\n"
"    p = mp.Process(target=foo, args=(q,))\n"
"    p.start()\n"
"    print(q.get())\n"
"    p.join()"

#: ../../library/multiprocessing.rst:217
msgid ""
":func:`set_start_method` should not be used more than once in the program."
msgstr ""

#: ../../library/multiprocessing.rst:220
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 ""

#: ../../library/multiprocessing.rst:225
msgid ""
"import multiprocessing as mp\n"
"\n"
"def foo(q):\n"
"    q.put('hello')\n"
"\n"
"if __name__ == '__main__':\n"
"    ctx = mp.get_context('spawn')\n"
"    q = ctx.Queue()\n"
"    p = ctx.Process(target=foo, args=(q,))\n"
"    p.start()\n"
"    print(q.get())\n"
"    p.join()"
msgstr ""
"import multiprocessing as mp\n"
"\n"
"def foo(q):\n"
"    q.put('hello')\n"
"\n"
"if __name__ == '__main__':\n"
"    ctx = mp.get_context('spawn')\n"
"    q = ctx.Queue()\n"
"    p = ctx.Process(target=foo, args=(q,))\n"
"    p.start()\n"
"    print(q.get())\n"
"    p.join()"

#: ../../library/multiprocessing.rst:238
msgid ""
"Note that objects related to one context may not be compatible with "
"processes for a different context.  In particular, locks created using the "
"*fork* context cannot be passed to processes started using the *spawn* or "
"*forkserver* start methods."
msgstr ""

#: ../../library/multiprocessing.rst:243
msgid ""
"Libraries using :mod:`!multiprocessing` or :class:`~concurrent.futures."
"ProcessPoolExecutor` should be designed to allow their users to provide "
"their own multiprocessing context.  Using a specific context of your own "
"within a library can lead to incompatibilities with the rest of the library "
"user's application.  Always document if your library requires a specific "
"start method."
msgstr ""

#: ../../library/multiprocessing.rst:252
msgid ""
"The ``'spawn'`` and ``'forkserver'`` start methods generally cannot be used "
"with \"frozen\" executables (i.e., binaries produced by packages like "
"**PyInstaller** and **cx_Freeze**) on POSIX systems. The ``'fork'`` start "
"method may work if code does not use threads."
msgstr ""

#: ../../library/multiprocessing.rst:259
msgid "Exchanging objects between processes"
msgstr ""

#: ../../library/multiprocessing.rst:261
msgid ""
":mod:`!multiprocessing` supports two types of communication channel between "
"processes:"
msgstr ""

#: ../../library/multiprocessing.rst:264
msgid "**Queues**"
msgstr ""

#: ../../library/multiprocessing.rst:266
msgid ""
"The :class:`Queue` class is a near clone of :class:`queue.Queue`.  For "
"example::"
msgstr ""

#: ../../library/multiprocessing.rst:269
msgid ""
"from multiprocessing import Process, Queue\n"
"\n"
"def f(q):\n"
"    q.put([42, None, 'hello'])\n"
"\n"
"if __name__ == '__main__':\n"
"    q = Queue()\n"
"    p = Process(target=f, args=(q,))\n"
"    p.start()\n"
"    print(q.get())    # prints \"[42, None, 'hello']\"\n"
"    p.join()"
msgstr ""
"from multiprocessing import Process, Queue\n"
"\n"
"def f(q):\n"
"    q.put([42, None, 'hello'])\n"
"\n"
"if __name__ == '__main__':\n"
"    q = Queue()\n"
"    p = Process(target=f, args=(q,))\n"
"    p.start()\n"
"    print(q.get())    # 印出 \"[42, None, 'hello']\"\n"
"    p.join()"

#: ../../library/multiprocessing.rst:281
msgid ""
"Queues are thread and process safe. Any object put into a :mod:`!"
"multiprocessing` queue will be serialized."
msgstr ""

#: ../../library/multiprocessing.rst:284
msgid "**Pipes**"
msgstr ""

#: ../../library/multiprocessing.rst:286
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 ""

#: ../../library/multiprocessing.rst:289
msgid ""
"from multiprocessing import Process, Pipe\n"
"\n"
"def f(conn):\n"
"    conn.send([42, None, 'hello'])\n"
"    conn.close()\n"
"\n"
"if __name__ == '__main__':\n"
"    parent_conn, child_conn = Pipe()\n"
"    p = Process(target=f, args=(child_conn,))\n"
"    p.start()\n"
"    print(parent_conn.recv())   # prints \"[42, None, 'hello']\"\n"
"    p.join()"
msgstr ""
"from multiprocessing import Process, Pipe\n"
"\n"
"def f(conn):\n"
"    conn.send([42, None, 'hello'])\n"
"    conn.close()\n"
"\n"
"if __name__ == '__main__':\n"
"    parent_conn, child_conn = Pipe()\n"
"    p = Process(target=f, args=(child_conn,))\n"
"    p.start()\n"
"    print(parent_conn.recv())   # 印出 \"[42, None, 'hello']\"\n"
"    p.join()"

#: ../../library/multiprocessing.rst:302
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 ""

#: ../../library/multiprocessing.rst:310
msgid ""
"The :meth:`~Connection.send` method serializes the object and :meth:"
"`~Connection.recv` re-creates the object."
msgstr ""

#: ../../library/multiprocessing.rst:314
msgid "Synchronization between processes"
msgstr ""

#: ../../library/multiprocessing.rst:316
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 ""

#: ../../library/multiprocessing.rst:320
msgid ""
"from multiprocessing import Process, Lock\n"
"\n"
"def f(l, i):\n"
"    l.acquire()\n"
"    try:\n"
"        print('hello world', i)\n"
"    finally:\n"
"        l.release()\n"
"\n"
"if __name__ == '__main__':\n"
"    lock = Lock()\n"
"\n"
"    for num in range(10):\n"
"        Process(target=f, args=(lock, num)).start()"
msgstr ""
"from multiprocessing import Process, Lock\n"
"\n"
"def f(l, i):\n"
"    l.acquire()\n"
"    try:\n"
"        print('hello world', i)\n"
"    finally:\n"
"        l.release()\n"
"\n"
"if __name__ == '__main__':\n"
"    lock = Lock()\n"
"\n"
"    for num in range(10):\n"
"        Process(target=f, args=(lock, num)).start()"

#: ../../library/multiprocessing.rst:335
msgid ""
"Without using the lock output from the different processes is liable to get "
"all mixed up."
msgstr ""

#: ../../library/multiprocessing.rst:340
msgid "Sharing state between processes"
msgstr ""

#: ../../library/multiprocessing.rst:342
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 ""

#: ../../library/multiprocessing.rst:346
msgid ""
"However, if you really do need to use some shared data then :mod:`!"
"multiprocessing` provides a couple of ways of doing so."
msgstr ""

#: ../../library/multiprocessing.rst:349
msgid "**Shared memory**"
msgstr ""

#: ../../library/multiprocessing.rst:351
msgid ""
"Data can be stored in a shared memory map using :class:`Value` or :class:"
"`Array`.  For example, the following code ::"
msgstr ""

#: ../../library/multiprocessing.rst:354
msgid ""
"from multiprocessing import Process, Value, Array\n"
"\n"
"def f(n, a):\n"
"    n.value = 3.1415927\n"
"    for i in range(len(a)):\n"
"        a[i] = -a[i]\n"
"\n"
"if __name__ == '__main__':\n"
"    num = Value('d', 0.0)\n"
"    arr = Array('i', range(10))\n"
"\n"
"    p = Process(target=f, args=(num, arr))\n"
"    p.start()\n"
"    p.join()\n"
"\n"
"    print(num.value)\n"
"    print(arr[:])"
msgstr ""
"from multiprocessing import Process, Value, Array\n"
"\n"
"def f(n, a):\n"
"    n.value = 3.1415927\n"
"    for i in range(len(a)):\n"
"        a[i] = -a[i]\n"
"\n"
"if __name__ == '__main__':\n"
"    num = Value('d', 0.0)\n"
"    arr = Array('i', range(10))\n"
"\n"
"    p = Process(target=f, args=(num, arr))\n"
"    p.start()\n"
"    p.join()\n"
"\n"
"    print(num.value)\n"
"    print(arr[:])"

#: ../../library/multiprocessing.rst:372 ../../library/multiprocessing.rst:422
msgid "will print ::"
msgstr ""

#: ../../library/multiprocessing.rst:374
msgid ""
"3.1415927\n"
"[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]"
msgstr ""
"3.1415927\n"
"[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]"

#: ../../library/multiprocessing.rst:377
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 ""

#: ../../library/multiprocessing.rst:382
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 ""

#: ../../library/multiprocessing.rst:386
msgid "**Server process**"
msgstr ""

#: ../../library/multiprocessing.rst:388
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 ""

#: ../../library/multiprocessing.rst:392
msgid ""
"A manager returned by :func:`Manager` will support types :class:`list`, :"
"class:`dict`, :class:`set`, :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 ""

#: ../../library/multiprocessing.rst:398
msgid ""
"from multiprocessing import Process, Manager\n"
"\n"
"def f(d, l, s):\n"
"    d[1] = '1'\n"
"    d['2'] = 2\n"
"    d[0.25] = None\n"
"    l.reverse()\n"
"    s.add('a')\n"
"    s.add('b')\n"
"\n"
"if __name__ == '__main__':\n"
"    with Manager() as manager:\n"
"        d = manager.dict()\n"
"        l = manager.list(range(10))\n"
"        s = manager.set()\n"
"\n"
"        p = Process(target=f, args=(d, l, s))\n"
"        p.start()\n"
"        p.join()\n"
"\n"
"        print(d)\n"
"        print(l)\n"
"        print(s)"
msgstr ""
"from multiprocessing import Process, Manager\n"
"\n"
"def f(d, l, s):\n"
"    d[1] = '1'\n"
"    d['2'] = 2\n"
"    d[0.25] = None\n"
"    l.reverse()\n"
"    s.add('a')\n"
"    s.add('b')\n"
"\n"
"if __name__ == '__main__':\n"
"    with Manager() as manager:\n"
"        d = manager.dict()\n"
"        l = manager.list(range(10))\n"
"        s = manager.set()\n"
"\n"
"        p = Process(target=f, args=(d, l, s))\n"
"        p.start()\n"
"        p.join()\n"
"\n"
"        print(d)\n"
"        print(l)\n"
"        print(s)"

#: ../../library/multiprocessing.rst:424
msgid ""
"{0.25: None, 1: '1', '2': 2}\n"
"[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
"{'a', 'b'}"
msgstr ""
"{0.25: None, 1: '1', '2': 2}\n"
"[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
"{'a', 'b'}"

#: ../../library/multiprocessing.rst:428
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 ""

#: ../../library/multiprocessing.rst:435
msgid "Using a pool of workers"
msgstr ""

#: ../../library/multiprocessing.rst:437
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 ""

#: ../../library/multiprocessing.rst:441
msgid "For example::"
msgstr "舉例來說： ::"

#: ../../library/multiprocessing.rst:443
msgid ""
"from multiprocessing import Pool, TimeoutError\n"
"import time\n"
"import os\n"
"\n"
"def f(x):\n"
"    return x*x\n"
"\n"
"if __name__ == '__main__':\n"
"    # start 4 worker processes\n"
"    with Pool(processes=4) as pool:\n"
"\n"
"        # print \"[0, 1, 4,..., 81]\"\n"
"        print(pool.map(f, range(10)))\n"
"\n"
"        # print same numbers in arbitrary order\n"
"        for i in pool.imap_unordered(f, range(10)):\n"
"            print(i)\n"
"\n"
"        # evaluate \"f(20)\" asynchronously\n"
"        res = pool.apply_async(f, (20,))      # runs in *only* one process\n"
"        print(res.get(timeout=1))             # prints \"400\"\n"
"\n"
"        # evaluate \"os.getpid()\" asynchronously\n"
"        res = pool.apply_async(os.getpid, ()) # runs in *only* one process\n"
"        print(res.get(timeout=1))             # prints the PID of that "
"process\n"
"\n"
"        # launching multiple evaluations asynchronously *may* use more "
"processes\n"
"        multiple_results = [pool.apply_async(os.getpid, ()) for i in "
"range(4)]\n"
"        print([res.get(timeout=1) for res in multiple_results])\n"
"\n"
"        # make a single worker sleep for 10 seconds\n"
"        res = pool.apply_async(time.sleep, (10,))\n"
"        try:\n"
"            print(res.get(timeout=1))\n"
"        except TimeoutError:\n"
"            print(\"We lacked patience and got a multiprocessing."
"TimeoutError\")\n"
"\n"
"        print(\"For the moment, the pool remains available for more work\")\n"
"\n"
"    # exiting the 'with'-block has stopped the pool\n"
"    print(\"Now the pool is closed and no longer available\")"
msgstr ""

#: ../../library/multiprocessing.rst:485
msgid ""
"Note that the methods of a pool should only ever be used by the process "
"which created it."
msgstr ""

#: ../../library/multiprocessing.rst:490
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 ""

#: ../../library/multiprocessing.rst:496
msgid ""
">>> from multiprocessing import Pool\n"
">>> p = Pool(5)\n"
">>> def f(x):\n"
"...     return x*x\n"
"...\n"
">>> with p:\n"
"...     p.map(f, [1,2,3])\n"
"Process PoolWorker-1:\n"
"Process PoolWorker-2:\n"
"Process PoolWorker-3:\n"
"Traceback (most recent call last):\n"
"Traceback (most recent call last):\n"
"Traceback (most recent call last):\n"
"AttributeError: Can't get attribute 'f' on <module '__main__' (<class "
"'_frozen_importlib.BuiltinImporter'>)>\n"
"AttributeError: Can't get attribute 'f' on <module '__main__' (<class "
"'_frozen_importlib.BuiltinImporter'>)>\n"
"AttributeError: Can't get attribute 'f' on <module '__main__' (<class "
"'_frozen_importlib.BuiltinImporter'>)>"
msgstr ""
">>> from multiprocessing import Pool\n"
">>> p = Pool(5)\n"
">>> def f(x):\n"
"...     return x*x\n"
"...\n"
">>> with p:\n"
"...     p.map(f, [1,2,3])\n"
"Process PoolWorker-1:\n"
"Process PoolWorker-2:\n"
"Process PoolWorker-3:\n"
"Traceback (most recent call last):\n"
"Traceback (most recent call last):\n"
"Traceback (most recent call last):\n"
"AttributeError: Can't get attribute 'f' on <module '__main__' (<class "
"'_frozen_importlib.BuiltinImporter'>)>\n"
"AttributeError: Can't get attribute 'f' on <module '__main__' (<class "
"'_frozen_importlib.BuiltinImporter'>)>\n"
"AttributeError: Can't get attribute 'f' on <module '__main__' (<class "
"'_frozen_importlib.BuiltinImporter'>)>"

#: ../../library/multiprocessing.rst:513
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 parent process "
"somehow.)"
msgstr ""

#: ../../library/multiprocessing.rst:519
msgid "Reference"
msgstr ""

#: ../../library/multiprocessing.rst:521
msgid ""
"The :mod:`!multiprocessing` package mostly replicates the API of the :mod:"
"`threading` module."
msgstr ""

#: ../../library/multiprocessing.rst:527
msgid "Global start method"
msgstr ""

#: ../../library/multiprocessing.rst:529
msgid ""
"Python supports several ways to create and initialize a process. The global "
"start method sets the default mechanism for creating a process."
msgstr ""

#: ../../library/multiprocessing.rst:532
msgid ""
"Several multiprocessing functions and methods that may also instantiate "
"certain objects will implicitly set the global start method to the system's "
"default, if it hasn’t been set already. The global start method can only be "
"set once. If you need to change the start method from the system default, "
"you must proactively set the global start method before calling functions or "
"methods, or creating these objects."
msgstr ""

#: ../../library/multiprocessing.rst:541
msgid ":class:`Process` and exceptions"
msgstr ":class:`Process` 與例外"

#: ../../library/multiprocessing.rst:546
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 ""

#: ../../library/multiprocessing.rst:550
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 ""

#: ../../library/multiprocessing.rst:561
msgid ""
"By default, no arguments are passed to *target*. The *args* argument, which "
"defaults to ``()``, can be used to specify a list or tuple of the arguments "
"to pass to *target*."
msgstr ""

#: ../../library/multiprocessing.rst:565
msgid ""
"If a subclass overrides the constructor, it must make sure it invokes the "
"base class constructor (``super().__init__()``) before doing anything else "
"to the process."
msgstr ""

#: ../../library/multiprocessing.rst:571
msgid ""
"In general, all arguments to :class:`Process` must be picklable.  This is "
"frequently observed when trying to create a :class:`Process` or use a :class:"
"`concurrent.futures.ProcessPoolExecutor` from a REPL with a locally defined "
"*target* function."
msgstr ""

#: ../../library/multiprocessing.rst:576
msgid ""
"Passing a callable object defined in the current REPL session causes the "
"child process to die via an uncaught :exc:`AttributeError` exception when "
"starting as *target* must have been defined within an importable module in "
"order to be loaded during unpickling."
msgstr ""

#: ../../library/multiprocessing.rst:581
msgid "Example of this uncatchable error from the child::"
msgstr ""

#: ../../library/multiprocessing.rst:583
msgid ""
">>> import multiprocessing as mp\n"
">>> def knigit():\n"
"...     print(\"Ni!\")\n"
"...\n"
">>> process = mp.Process(target=knigit)\n"
">>> process.start()\n"
">>> Traceback (most recent call last):\n"
"  File \".../multiprocessing/spawn.py\", line ..., in spawn_main\n"
"  File \".../multiprocessing/spawn.py\", line ..., in _main\n"
"AttributeError: module '__main__' has no attribute 'knigit'\n"
">>> process\n"
"<SpawnProcess name='SpawnProcess-1' pid=379473 parent=378707 stopped "
"exitcode=1>"
msgstr ""
">>> import multiprocessing as mp\n"
">>> def knigit():\n"
"...     print(\"Ni!\")\n"
"...\n"
">>> process = mp.Process(target=knigit)\n"
">>> process.start()\n"
">>> Traceback (most recent call last):\n"
"  File \".../multiprocessing/spawn.py\", line ..., in spawn_main\n"
"  File \".../multiprocessing/spawn.py\", line ..., in _main\n"
"AttributeError: module '__main__' has no attribute 'knigit'\n"
">>> process\n"
"<SpawnProcess name='SpawnProcess-1' pid=379473 parent=378707 stopped "
"exitcode=1>"

#: ../../library/multiprocessing.rst:596
msgid ""
"See :ref:`multiprocessing-programming-spawn`.  While this restriction is not "
"true if using the ``\"fork\"`` start method, as of Python ``3.14`` that is "
"no longer the default on any platform.  See :ref:`multiprocessing-start-"
"methods`. See also :gh:`132898`."
msgstr ""

#: ../../library/multiprocessing.rst:602
msgid "Added the *daemon* parameter."
msgstr "新增 *daemon* 參數。"

#: ../../library/multiprocessing.rst:607
msgid "Method representing the process's activity."
msgstr ""

#: ../../library/multiprocessing.rst:609
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 ""

#: ../../library/multiprocessing.rst:614
msgid ""
"Using a list or tuple as the *args* argument passed to :class:`Process` "
"achieves the same effect."
msgstr ""

#: ../../library/multiprocessing.rst:617
msgid "Example::"
msgstr "範例： ::"

#: ../../library/multiprocessing.rst:619
msgid ""
">>> from multiprocessing import Process\n"
">>> p = Process(target=print, args=[1])\n"
">>> p.run()\n"
"1\n"
">>> p = Process(target=print, args=(1,))\n"
">>> p.run()\n"
"1"
msgstr ""
">>> from multiprocessing import Process\n"
">>> p = Process(target=print, args=[1])\n"
">>> p.run()\n"
"1\n"
">>> p = Process(target=print, args=(1,))\n"
">>> p.run()\n"
"1"

#: ../../library/multiprocessing.rst:629
msgid "Start the process's activity."
msgstr ""

#: ../../library/multiprocessing.rst:631
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 ""

#: ../../library/multiprocessing.rst:636
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 ""

#: ../../library/multiprocessing.rst:643
msgid "A process can be joined many times."
msgstr ""

#: ../../library/multiprocessing.rst:645
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 ""

#: ../../library/multiprocessing.rst:650
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 ""

#: ../../library/multiprocessing.rst:654
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 ""

#: ../../library/multiprocessing.rst:661
msgid "Return whether the process is alive."
msgstr ""

#: ../../library/multiprocessing.rst:663
msgid ""
"Roughly, a process object is alive from the moment the :meth:`start` method "
"returns until the child process terminates."
msgstr ""

#: ../../library/multiprocessing.rst:668
msgid ""
"The process's daemon flag, a Boolean value.  This must be set before :meth:"
"`start` is called."
msgstr ""

#: ../../library/multiprocessing.rst:671
msgid "The initial value is inherited from the creating process."
msgstr ""

#: ../../library/multiprocessing.rst:673
msgid ""
"When a process exits, it attempts to terminate all of its daemonic child "
"processes."
msgstr ""

#: ../../library/multiprocessing.rst:676
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 ""

#: ../../library/multiprocessing.rst:682
msgid ""
"In addition to the  :class:`threading.Thread` API, :class:`Process` objects "
"also support the following attributes and methods:"
msgstr ""

#: ../../library/multiprocessing.rst:687
msgid ""
"Return the process ID.  Before the process is spawned, this will be ``None``."
msgstr ""

#: ../../library/multiprocessing.rst:692
msgid ""
"The child's exit code.  This will be ``None`` if the process has not yet "
"terminated."
msgstr ""

#: ../../library/multiprocessing.rst:695
msgid ""
"If the child's :meth:`run` method returned normally, the exit code will be "
"0.  If it terminated via :func:`sys.exit` with an integer argument *N*, the "
"exit code will be *N*."
msgstr ""

#: ../../library/multiprocessing.rst:699
msgid ""
"If the child terminated due to an exception not caught within :meth:`run`, "
"the exit code will be 1.  If it was terminated by signal *N*, the exit code "
"will be the negative value *-N*."
msgstr ""

#: ../../library/multiprocessing.rst:705
msgid "The process's authentication key (a byte string)."
msgstr ""

#: ../../library/multiprocessing.rst:707
msgid ""
"When :mod:`!multiprocessing` is initialized the main process is assigned a "
"random string using :func:`os.urandom`."
msgstr ""

#: ../../library/multiprocessing.rst:710
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 ""

#: ../../library/multiprocessing.rst:714
msgid "See :ref:`multiprocessing-auth-keys`."
msgstr "參閱 :ref:`multiprocessing-auth-keys`。"

#: ../../library/multiprocessing.rst:718
msgid ""
"A numeric handle of a system object which will become \"ready\" when the "
"process ends."
msgstr ""

#: ../../library/multiprocessing.rst:721
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 ""

#: ../../library/multiprocessing.rst:725
msgid ""
"On Windows, this is an OS handle usable with the ``WaitForSingleObject`` and "
"``WaitForMultipleObjects`` family of API calls.  On POSIX, this is a file "
"descriptor usable with primitives from the :mod:`select` module."
msgstr ""

#: ../../library/multiprocessing.rst:733
msgid ""
"Terminate the process. Works on POSIX using the :py:const:`~signal.SIGINT` "
"signal. Behavior on Windows is undefined."
msgstr ""

#: ../../library/multiprocessing.rst:736
msgid ""
"By default, this terminates the child process by raising :exc:"
"`KeyboardInterrupt`. This behavior can be altered by setting the respective "
"signal handler in the child process :func:`signal.signal` for :py:const:"
"`~signal.SIGINT`."
msgstr ""

#: ../../library/multiprocessing.rst:740
msgid ""
"Note: if the child process catches and discards :exc:`KeyboardInterrupt`, "
"the process will not be terminated."
msgstr ""

#: ../../library/multiprocessing.rst:743
msgid ""
"Note: the default behavior will also set :attr:`exitcode` to ``1`` as if an "
"uncaught exception was raised in the child process. To have a different :"
"attr:`exitcode` you may simply catch :exc:`KeyboardInterrupt` and call "
"``exit(your_code)``."
msgstr ""

#: ../../library/multiprocessing.rst:752
msgid ""
"Terminate the process.  On POSIX this is done using the :py:const:`~signal."
"SIGTERM` signal; on Windows :c:func:`!TerminateProcess` is used.  Note that "
"exit handlers and finally clauses, etc., will not be executed."
msgstr ""

#: ../../library/multiprocessing.rst:756
msgid ""
"Note that descendant processes of the process will *not* be terminated -- "
"they will simply become orphaned."
msgstr ""

#: ../../library/multiprocessing.rst:761
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 ""

#: ../../library/multiprocessing.rst:769
msgid "Same as :meth:`terminate` but using the ``SIGKILL`` signal on POSIX."
msgstr ""

#: ../../library/multiprocessing.rst:775
msgid ""
"Close the :class:`Process` object, releasing all resources associated with "
"it.  :exc:`ValueError` is raised if the underlying process is still "
"running.  Once :meth:`close` returns successfully, most other methods and "
"attributes of the :class:`Process` object will raise :exc:`ValueError`."
msgstr ""

#: ../../library/multiprocessing.rst:783
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 ""

#: ../../library/multiprocessing.rst:787
msgid "Example usage of some of the methods of :class:`Process`:"
msgstr ""

#: ../../library/multiprocessing.rst:789
msgid ""
">>> import multiprocessing, time, signal\n"
">>> mp_context = multiprocessing.get_context('spawn')\n"
">>> p = mp_context.Process(target=time.sleep, args=(1000,))\n"
">>> print(p, p.is_alive())\n"
"<...Process ... initial> False\n"
">>> p.start()\n"
">>> print(p, p.is_alive())\n"
"<...Process ... started> True\n"
">>> p.terminate()\n"
">>> time.sleep(0.1)\n"
">>> print(p, p.is_alive())\n"
"<...Process ... stopped exitcode=-SIGTERM> False\n"
">>> p.exitcode == -signal.SIGTERM\n"
"True"
msgstr ""
">>> import multiprocessing, time, signal\n"
">>> mp_context = multiprocessing.get_context('spawn')\n"
">>> p = mp_context.Process(target=time.sleep, args=(1000,))\n"
">>> print(p, p.is_alive())\n"
"<...Process ... initial> False\n"
">>> p.start()\n"
">>> print(p, p.is_alive())\n"
"<...Process ... started> True\n"
">>> p.terminate()\n"
">>> time.sleep(0.1)\n"
">>> print(p, p.is_alive())\n"
"<...Process ... stopped exitcode=-SIGTERM> False\n"
">>> p.exitcode == -signal.SIGTERM\n"
"True"

#: ../../library/multiprocessing.rst:808
msgid "The base class of all :mod:`!multiprocessing` exceptions."
msgstr ""

#: ../../library/multiprocessing.rst:812
msgid ""
"Exception raised by :meth:`Connection.recv_bytes_into` when the supplied "
"buffer object is too small for the message read."
msgstr ""

#: ../../library/multiprocessing.rst:815
msgid ""
"If ``e`` is an instance of :exc:`BufferTooShort` then ``e.args[0]`` will "
"give the message as a byte string."
msgstr ""

#: ../../library/multiprocessing.rst:820
msgid "Raised when there is an authentication error."
msgstr ""

#: ../../library/multiprocessing.rst:824
msgid "Raised by methods with a timeout when the timeout expires."
msgstr ""

#: ../../library/multiprocessing.rst:827
msgid "Pipes and Queues"
msgstr ""

#: ../../library/multiprocessing.rst:829
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 ""

#: ../../library/multiprocessing.rst:833
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 ""

#: ../../library/multiprocessing.rst:836
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 ""

#: ../../library/multiprocessing.rst:843
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 ""

#: ../../library/multiprocessing.rst:848
msgid ""
"One difference from other Python queue implementations, is that :mod:`!"
"multiprocessing` queues serializes all objects that are put into them using :"
"mod:`pickle`. The object returned by the get method is a re-created object "
"that does not share memory with the original object."
msgstr ""

#: ../../library/multiprocessing.rst:853
msgid ""
"Note that one can also create a shared queue by using a manager object -- "
"see :ref:`multiprocessing-managers`."
msgstr ""

#: ../../library/multiprocessing.rst:858
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 ""

#: ../../library/multiprocessing.rst:865
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 ""

#: ../../library/multiprocessing.rst:872
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 ""

#: ../../library/multiprocessing.rst:877
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 ""

#: ../../library/multiprocessing.rst:884
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 ""

#: ../../library/multiprocessing.rst:891
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 ""

#: ../../library/multiprocessing.rst:896
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 ""

#: ../../library/multiprocessing.rst:901
msgid ""
"Note that a queue created using a manager does not have this issue.  See :"
"ref:`multiprocessing-programming`."
msgstr ""

#: ../../library/multiprocessing.rst:904
msgid ""
"For an example of the usage of queues for interprocess communication see :"
"ref:`multiprocessing-examples`."
msgstr ""

#: ../../library/multiprocessing.rst:910
msgid ""
"Returns a pair ``(conn1, conn2)`` of :class:`~multiprocessing.connection."
"Connection` objects representing the ends of a pipe."
msgstr ""

#: ../../library/multiprocessing.rst:914
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 ""

#: ../../library/multiprocessing.rst:919
msgid ""
"The :meth:`~multiprocessing.Connection.send` method serializes the object "
"using :mod:`pickle` and the :meth:`~multiprocessing.Connection.recv` re-"
"creates the object."
msgstr ""

#: ../../library/multiprocessing.rst:924
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 ""

#: ../../library/multiprocessing.rst:928 ../../library/multiprocessing.rst:1047
#: ../../library/multiprocessing.rst:1080
#: ../../library/multiprocessing.rst:1436
#: ../../library/multiprocessing.rst:1446
#: ../../library/multiprocessing.rst:1469
#: ../../library/multiprocessing.rst:1479
#: ../../library/multiprocessing.rst:1496
#: ../../library/multiprocessing.rst:1556
#: ../../library/multiprocessing.rst:1618
msgid ""
"Instantiating this class may set the global start method. See :ref:`global-"
"start-method` for more details."
msgstr ""

#: ../../library/multiprocessing.rst:931
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 ""

#: ../../library/multiprocessing.rst:934
msgid ""
":class:`Queue` implements all the methods of :class:`queue.Queue` except "
"for :meth:`~queue.Queue.task_done`, :meth:`~queue.Queue.join`, and :meth:"
"`~queue.Queue.shutdown`."
msgstr ""

#: ../../library/multiprocessing.rst:940
msgid ""
"Return the approximate size of the queue.  Because of multithreading/"
"multiprocessing semantics, this number is not reliable."
msgstr ""

#: ../../library/multiprocessing.rst:943 ../../library/multiprocessing.rst:1629
msgid ""
"Note that this may raise :exc:`NotImplementedError` on platforms like macOS "
"where ``sem_getvalue()`` is not implemented."
msgstr ""

#: ../../library/multiprocessing.rst:948
msgid ""
"Return ``True`` if the queue is empty, ``False`` otherwise.  Because of "
"multithreading/multiprocessing semantics, this is not reliable."
msgstr ""

#: ../../library/multiprocessing.rst:951
msgid "May raise an :exc:`OSError` on closed queues. (not guaranteed)"
msgstr ""

#: ../../library/multiprocessing.rst:955
msgid ""
"Return ``True`` if the queue is full, ``False`` otherwise.  Because of "
"multithreading/multiprocessing semantics, this is not reliable."
msgstr ""

#: ../../library/multiprocessing.rst:960
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 ""

#: ../../library/multiprocessing.rst:969
msgid ""
"If the queue is closed, :exc:`ValueError` is raised instead of :exc:"
"`AssertionError`."
msgstr ""

#: ../../library/multiprocessing.rst:975
msgid "Equivalent to ``put(obj, False)``."
msgstr "相當於 ``put(obj, False)``。"

#: ../../library/multiprocessing.rst:979
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 ""

#: ../../library/multiprocessing.rst:987
msgid ""
"If the queue is closed, :exc:`ValueError` is raised instead of :exc:"
"`OSError`."
msgstr ""

#: ../../library/multiprocessing.rst:993
msgid "Equivalent to ``get(False)``."
msgstr "相當於 ``get(False)``。"

#: ../../library/multiprocessing.rst:995
msgid ""
":class:`multiprocessing.Queue` has a few additional methods not found in :"
"class:`queue.Queue`.  These methods are usually unnecessary for most code:"
msgstr ""

#: ../../library/multiprocessing.rst:1001
#: ../../library/multiprocessing.rst:1052
msgid "Close the queue: release internal resources."
msgstr ""

#: ../../library/multiprocessing.rst:1003
msgid ""
"A queue must not be used anymore after it is closed. For example, :meth:"
"`~Queue.get`, :meth:`~Queue.put` and :meth:`~Queue.empty` methods must no "
"longer be called."
msgstr ""

#: ../../library/multiprocessing.rst:1007
msgid ""
"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 ""

#: ../../library/multiprocessing.rst:1013
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 ""

#: ../../library/multiprocessing.rst:1017
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 ""

#: ../../library/multiprocessing.rst:1023
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 ""

#: ../../library/multiprocessing.rst:1027
msgid ""
"A better name for this method might be ``allow_exit_without_flush()``.  It "
"is likely to cause enqueued data to be 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 ""

#: ../../library/multiprocessing.rst:1036
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 ""

#: ../../library/multiprocessing.rst:1045
msgid ""
"It is a simplified :class:`Queue` type, very close to a locked :class:`Pipe`."
msgstr ""

#: ../../library/multiprocessing.rst:1054
msgid ""
"A queue must not be used anymore after it is closed. For example, :meth:"
"`get`, :meth:`put` and :meth:`empty` methods must no longer be called."
msgstr ""

#: ../../library/multiprocessing.rst:1062
msgid "Return ``True`` if the queue is empty, ``False`` otherwise."
msgstr ""

#: ../../library/multiprocessing.rst:1064
msgid "Always raises an :exc:`OSError` if the SimpleQueue is closed."
msgstr ""

#: ../../library/multiprocessing.rst:1068
msgid "Remove and return an item from the queue."
msgstr ""

#: ../../library/multiprocessing.rst:1072
msgid "Put *item* into the queue."
msgstr ""

#: ../../library/multiprocessing.rst:1077
msgid ""
":class:`JoinableQueue`, a :class:`Queue` subclass, is a queue which "
"additionally has :meth:`task_done` and :meth:`join` methods."
msgstr ""

#: ../../library/multiprocessing.rst:1085
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 ""

#: ../../library/multiprocessing.rst:1090
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 ""

#: ../../library/multiprocessing.rst:1094
msgid ""
"Raises a :exc:`ValueError` if called more times than there were items placed "
"in the queue."
msgstr ""

#: ../../library/multiprocessing.rst:1100
msgid "Block until all items in the queue have been gotten and processed."
msgstr ""

#: ../../library/multiprocessing.rst:1102
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 ""

#: ../../library/multiprocessing.rst:1110
msgid "Miscellaneous"
msgstr ""

#: ../../library/multiprocessing.rst:1114
msgid "Return list of all live children of the current process."
msgstr ""

#: ../../library/multiprocessing.rst:1116
msgid ""
"Calling this has the side effect of \"joining\" any processes which have "
"already finished."
msgstr ""

#: ../../library/multiprocessing.rst:1121
msgid "Return the number of CPUs in the system."
msgstr ""

#: ../../library/multiprocessing.rst:1123
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 :func:`os."
"process_cpu_count` (or ``len(os.sched_getaffinity(0))``)."
msgstr ""

#: ../../library/multiprocessing.rst:1127
msgid ""
"When the number of CPUs cannot be determined a :exc:`NotImplementedError` is "
"raised."
msgstr ""

#: ../../library/multiprocessing.rst:1131
msgid ":func:`os.cpu_count` :func:`os.process_cpu_count`"
msgstr ":func:`os.cpu_count` :func:`os.process_cpu_count`"

#: ../../library/multiprocessing.rst:1136
msgid ""
"The return value can also be overridden using the :option:`-X cpu_count <-"
"X>` flag or :envvar:`PYTHON_CPU_COUNT` as this is merely a wrapper around "
"the :mod:`os` cpu count APIs."
msgstr ""

#: ../../library/multiprocessing.rst:1142
msgid ""
"Return the :class:`Process` object corresponding to the current process."
msgstr ""

#: ../../library/multiprocessing.rst:1144
msgid "An analogue of :func:`threading.current_thread`."
msgstr ""

#: ../../library/multiprocessing.rst:1148
msgid ""
"Return the :class:`Process` object corresponding to the parent process of "
"the :func:`current_process`. For the main process, ``parent_process`` will "
"be ``None``."
msgstr ""

#: ../../library/multiprocessing.rst:1156
msgid ""
"Add support for when a program which uses :mod:`!multiprocessing` has been "
"frozen to produce an executable.  (Has been tested with **py2exe**, "
"**PyInstaller** and **cx_Freeze**.)"
msgstr ""

#: ../../library/multiprocessing.rst:1160
msgid ""
"One needs to call this function straight after the ``if __name__ == "
"'__main__'`` line of the main module.  For example::"
msgstr ""

#: ../../library/multiprocessing.rst:1163
msgid ""
"from multiprocessing import Process, freeze_support\n"
"\n"
"def f():\n"
"    print('hello world!')\n"
"\n"
"if __name__ == '__main__':\n"
"    freeze_support()\n"
"    Process(target=f).start()"
msgstr ""
"from multiprocessing import Process, freeze_support\n"
"\n"
"def f():\n"
"    print('hello world!')\n"
"\n"
"if __name__ == '__main__':\n"
"    freeze_support()\n"
"    Process(target=f).start()"

#: ../../library/multiprocessing.rst:1172
msgid ""
"If the ``freeze_support()`` line is omitted then trying to run the frozen "
"executable will raise :exc:`RuntimeError`."
msgstr ""

#: ../../library/multiprocessing.rst:1175
msgid ""
"Calling ``freeze_support()`` has no effect when the start method is not "
"*spawn*. In addition, if the module is being run normally by the Python "
"interpreter (the program has not been frozen), then ``freeze_support()`` has "
"no effect."
msgstr ""

#: ../../library/multiprocessing.rst:1182
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'``.  Not all platforms support all methods.  See :ref:"
"`multiprocessing-start-methods`."
msgstr ""

#: ../../library/multiprocessing.rst:1191
msgid ""
"Return a context object which has the same attributes as the :mod:`!"
"multiprocessing` module."
msgstr ""

#: ../../library/multiprocessing.rst:1194
msgid ""
"If *method* is ``None`` then the default context is returned. Note that if "
"the global start method has not been set, this will set it to the system "
"default See :ref:`global-start-method` for more details. Otherwise *method* "
"should be ``'fork'``, ``'spawn'``, ``'forkserver'``.  :exc:`ValueError` is "
"raised if the specified start method is not available.  See :ref:"
"`multiprocessing-start-methods`."
msgstr ""

#: ../../library/multiprocessing.rst:1205
msgid "Return the name of start method used for starting processes."
msgstr ""

#: ../../library/multiprocessing.rst:1207
msgid ""
"If the global start method is not set and *allow_none* is ``False``, the "
"global start method is set to the default, and its name is returned. See :"
"ref:`global-start-method` for more details."
msgstr ""

#: ../../library/multiprocessing.rst:1211
msgid ""
"The return value can be ``'fork'``, ``'spawn'``, ``'forkserver'`` or "
"``None``.  See :ref:`multiprocessing-start-methods`."
msgstr ""

#: ../../library/multiprocessing.rst:1218
msgid ""
"On macOS, the *spawn* start method is now the default.  The *fork* start "
"method should be considered unsafe as it can lead to crashes of the "
"subprocess. See :issue:`33725`."
msgstr ""

#: ../../library/multiprocessing.rst:1224
msgid ""
"Set 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 something like ::"
msgstr ""

#: ../../library/multiprocessing.rst:1228
msgid "set_executable(os.path.join(sys.exec_prefix, 'pythonw.exe'))"
msgstr "set_executable(os.path.join(sys.exec_prefix, 'pythonw.exe'))"

#: ../../library/multiprocessing.rst:1230
msgid "before they can create child processes."
msgstr ""

#: ../../library/multiprocessing.rst:1232
msgid "Now supported on POSIX when the ``'spawn'`` start method is used."
msgstr ""

#: ../../library/multiprocessing.rst:1235
msgid "Accepts a :term:`path-like object`."
msgstr "接受一個\\ :term:`類路徑物件 <path-like object>`。"

#: ../../library/multiprocessing.rst:1240
msgid ""
"Set a list of module names for the forkserver main process to attempt to "
"import so that their already imported state is inherited by forked "
"processes. Any :exc:`ImportError` when doing so is silently ignored. This "
"can be used as a performance enhancement to avoid repeated work in every "
"process."
msgstr ""

#: ../../library/multiprocessing.rst:1246
msgid ""
"For this to work, it must be called before the forkserver process has been "
"launched (before creating a :class:`Pool` or starting a :class:`Process`)."
msgstr ""

#: ../../library/multiprocessing.rst:1249
msgid ""
"Only meaningful when using the ``'forkserver'`` start method. See :ref:"
"`multiprocessing-start-methods`."
msgstr ""

#: ../../library/multiprocessing.rst:1256
msgid ""
"Set the method which should be used to start child processes. The *method* "
"argument can be ``'fork'``, ``'spawn'`` or ``'forkserver'``. Raises :exc:"
"`RuntimeError` if the start method has already been set and *force* is not "
"``True``.  If *method* is ``None`` and *force* is ``True`` then the start "
"method is set to ``None``.  If *method* is ``None`` and *force* is ``False`` "
"then the context is set to the default context."
msgstr ""

#: ../../library/multiprocessing.rst:1263
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 ""

#: ../../library/multiprocessing.rst:1267
msgid "See :ref:`multiprocessing-start-methods`."
msgstr "參閱 :ref:`multiprocessing-start-methods`。"

#: ../../library/multiprocessing.rst:1273
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 ""

#: ../../library/multiprocessing.rst:1280
msgid "Connection Objects"
msgstr ""

#: ../../library/multiprocessing.rst:1284
msgid ""
"Connection objects allow the sending and receiving of picklable objects or "
"strings.  They can be thought of as message oriented connected sockets."
msgstr ""

#: ../../library/multiprocessing.rst:1287
msgid ""
"Connection objects are usually created using :func:`Pipe <multiprocessing."
"Pipe>` -- see also :ref:`multiprocessing-listeners-clients`."
msgstr ""

#: ../../library/multiprocessing.rst:1295
msgid ""
"Send an object to the other end of the connection which should be read "
"using :meth:`recv`."
msgstr ""

#: ../../library/multiprocessing.rst:1298
msgid ""
"The object must be picklable.  Very large pickles (approximately 32 MiB+, "
"though it depends on the OS) may raise a :exc:`ValueError` exception."
msgstr ""

#: ../../library/multiprocessing.rst:1303
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 ""

#: ../../library/multiprocessing.rst:1310
msgid "Return the file descriptor or handle used by the connection."
msgstr ""

#: ../../library/multiprocessing.rst:1314
msgid "Close the connection."
msgstr ""

#: ../../library/multiprocessing.rst:1316
msgid "This is called automatically when the connection is garbage collected."
msgstr ""

#: ../../library/multiprocessing.rst:1320
msgid "Return whether there is any data available to be read."
msgstr ""

#: ../../library/multiprocessing.rst:1322
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 ""

#: ../../library/multiprocessing.rst:1326
msgid ""
"Note that multiple connection objects may be polled at once by using :func:"
"`multiprocessing.connection.wait`."
msgstr ""

#: ../../library/multiprocessing.rst:1331
msgid "Send byte data from a :term:`bytes-like object` as a complete message."
msgstr ""

#: ../../library/multiprocessing.rst:1333
msgid ""
"If *offset* is given then data is read from that position in *buf*.  If "
"*size* is given then that many bytes will be read from *buf*.  Very large "
"buffers (approximately 32 MiB+, though it depends on the OS) may raise a :"
"exc:`ValueError` exception"
msgstr ""

#: ../../library/multiprocessing.rst:1340
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 ""

#: ../../library/multiprocessing.rst:1345
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 ""

#: ../../library/multiprocessing.rst:1349
msgid ""
"This function used to raise :exc:`IOError`, which is now an alias of :exc:"
"`OSError`."
msgstr ""

#: ../../library/multiprocessing.rst:1356
msgid ""
"Read into *buf* 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 ""

#: ../../library/multiprocessing.rst:1362
msgid ""
"*buf* 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 *buf* (in bytes)."
msgstr ""

#: ../../library/multiprocessing.rst:1367
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 ""

#: ../../library/multiprocessing.rst:1371
msgid ""
"Connection objects themselves can now be transferred between processes "
"using :meth:`Connection.send` and :meth:`Connection.recv`."
msgstr ""

#: ../../library/multiprocessing.rst:1375
msgid ""
"Connection objects also now support the context management protocol -- see :"
"ref:`typecontextmanager`.  :meth:`~contextmanager.__enter__` returns the "
"connection object, and :meth:`~contextmanager.__exit__` calls :meth:`close`."
msgstr ""

#: ../../library/multiprocessing.rst:1379
msgid "For example:"
msgstr "舉例來說："

#: ../../library/multiprocessing.rst:1381
msgid ""
">>> from multiprocessing import Pipe\n"
">>> a, b = Pipe()\n"
">>> a.send([1, 'hello', None])\n"
">>> b.recv()\n"
"[1, 'hello', None]\n"
">>> b.send_bytes(b'thank you')\n"
">>> a.recv_bytes()\n"
"b'thank you'\n"
">>> import array\n"
">>> arr1 = array.array('i', range(5))\n"
">>> arr2 = array.array('i', [0] * 10)\n"
">>> a.send_bytes(arr1)\n"
">>> count = b.recv_bytes_into(arr2)\n"
">>> assert count == len(arr1) * arr1.itemsize\n"
">>> arr2\n"
"array('i', [0, 1, 2, 3, 4, 0, 0, 0, 0, 0])"
msgstr ""
">>> from multiprocessing import Pipe\n"
">>> a, b = Pipe()\n"
">>> a.send([1, 'hello', None])\n"
">>> b.recv()\n"
"[1, 'hello', None]\n"
">>> b.send_bytes(b'thank you')\n"
">>> a.recv_bytes()\n"
"b'thank you'\n"
">>> import array\n"
">>> arr1 = array.array('i', range(5))\n"
">>> arr2 = array.array('i', [0] * 10)\n"
">>> a.send_bytes(arr1)\n"
">>> count = b.recv_bytes_into(arr2)\n"
">>> assert count == len(arr1) * arr1.itemsize\n"
">>> arr2\n"
"array('i', [0, 1, 2, 3, 4, 0, 0, 0, 0, 0])"

#: ../../library/multiprocessing.rst:1404
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 ""

#: ../../library/multiprocessing.rst:1408
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 ""

#: ../../library/multiprocessing.rst:1415
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 ""

#: ../../library/multiprocessing.rst:1421
msgid "Synchronization primitives"
msgstr ""

#: ../../library/multiprocessing.rst:1425
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 ""

#: ../../library/multiprocessing.rst:1429
msgid ""
"Note that one can also create synchronization primitives by using a manager "
"object -- see :ref:`multiprocessing-managers`."
msgstr ""

#: ../../library/multiprocessing.rst:1434
msgid "A barrier object: a clone of :class:`threading.Barrier`."
msgstr ""

#: ../../library/multiprocessing.rst:1443
msgid ""
"A bounded semaphore object: a close analog of :class:`threading."
"BoundedSemaphore`."
msgstr ""

#: ../../library/multiprocessing.rst:1449
#: ../../library/multiprocessing.rst:1621
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 ""

#: ../../library/multiprocessing.rst:1454
#: ../../library/multiprocessing.rst:1539
#: ../../library/multiprocessing.rst:1609
#: ../../library/multiprocessing.rst:1635
msgid "Return a boolean indicating whether this object is locked right now."
msgstr ""

#: ../../library/multiprocessing.rst:1459
msgid ""
"On macOS, this is indistinguishable from :class:`Semaphore` because "
"``sem_getvalue()`` is not implemented on that platform."
msgstr ""

#: ../../library/multiprocessing.rst:1464
msgid "A condition variable: an alias for :class:`threading.Condition`."
msgstr ""

#: ../../library/multiprocessing.rst:1466
msgid ""
"If *lock* is specified then it should be a :class:`Lock` or :class:`RLock` "
"object from :mod:`!multiprocessing`."
msgstr ""

#: ../../library/multiprocessing.rst:1472
#: ../../library/multiprocessing.rst:2067
msgid "The :meth:`~threading.Condition.wait_for` method was added."
msgstr "新增 :meth:`~threading.Condition.wait_for` 方法。"

#: ../../library/multiprocessing.rst:1477
msgid "A clone of :class:`threading.Event`."
msgstr ""

#: ../../library/multiprocessing.rst:1484
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 ""

#: ../../library/multiprocessing.rst:1492
msgid ""
"Note that :class:`Lock` is actually a factory function which returns an "
"instance of ``multiprocessing.synchronize.Lock`` initialized with a default "
"context."
msgstr ""

#: ../../library/multiprocessing.rst:1499
msgid ""
":class:`Lock` supports the :term:`context manager` protocol and thus may be "
"used in :keyword:`with` statements."
msgstr ""

#: ../../library/multiprocessing.rst:1504
#: ../../library/multiprocessing.rst:1565
msgid "Acquire a lock, blocking or non-blocking."
msgstr ""

#: ../../library/multiprocessing.rst:1506
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 ""

#: ../../library/multiprocessing.rst:1511
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 ""

#: ../../library/multiprocessing.rst:1515
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 ""

#: ../../library/multiprocessing.rst:1530
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 ""

#: ../../library/multiprocessing.rst:1533
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 ""

#: ../../library/multiprocessing.rst:1546
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 ""

#: ../../library/multiprocessing.rst:1552
msgid ""
"Note that :class:`RLock` is actually a factory function which returns an "
"instance of ``multiprocessing.synchronize.RLock`` initialized with a default "
"context."
msgstr ""

#: ../../library/multiprocessing.rst:1559
msgid ""
":class:`RLock` supports the :term:`context manager` protocol and thus may be "
"used in :keyword:`with` statements."
msgstr ""

#: ../../library/multiprocessing.rst:1567
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 ""

#: ../../library/multiprocessing.rst:1577
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 ""

#: ../../library/multiprocessing.rst:1585
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 ""

#: ../../library/multiprocessing.rst:1592
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 ""

#: ../../library/multiprocessing.rst:1600
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 ""

#: ../../library/multiprocessing.rst:1616
msgid "A semaphore object: a close analog of :class:`threading.Semaphore`."
msgstr ""

#: ../../library/multiprocessing.rst:1627
msgid "Return the current value of semaphore."
msgstr ""

#: ../../library/multiprocessing.rst:1642
msgid ""
"On macOS, ``sem_timedwait`` is unsupported, so calling ``acquire()`` with a "
"timeout will emulate that function's behavior using a sleeping loop."
msgstr ""

#: ../../library/multiprocessing.rst:1647
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 ""

#: ../../library/multiprocessing.rst:1655
msgid "Shared :mod:`ctypes` Objects"
msgstr "共享的 :mod:`ctypes` 物件"

#: ../../library/multiprocessing.rst:1657
msgid ""
"It is possible to create shared objects using shared memory which can be "
"inherited by child processes."
msgstr ""

#: ../../library/multiprocessing.rst:1662
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 ""

#: ../../library/multiprocessing.rst:1666
#: ../../library/multiprocessing.rst:1756
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 ""

#: ../../library/multiprocessing.rst:1670
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 ""

#: ../../library/multiprocessing.rst:1677
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 ""

#: ../../library/multiprocessing.rst:1681
msgid "counter.value += 1"
msgstr "counter.value += 1"

#: ../../library/multiprocessing.rst:1683
msgid ""
"Assuming the associated lock is recursive (which it is by default) you can "
"instead do ::"
msgstr ""

#: ../../library/multiprocessing.rst:1686
msgid ""
"with counter.get_lock():\n"
"    counter.value += 1"
msgstr ""
"with counter.get_lock():\n"
"    counter.value += 1"

#: ../../library/multiprocessing.rst:1689
msgid "Note that *lock* is a keyword-only argument."
msgstr ""

#: ../../library/multiprocessing.rst:1693
msgid ""
"Return a ctypes array allocated from shared memory.  By default the return "
"value is actually a synchronized wrapper for the array."
msgstr ""

#: ../../library/multiprocessing.rst:1696
msgid ""
"*typecode_or_type* determines the type of the elements of the returned "
"array: it is either a :ref:`ctypes type <ctypes-fundamental-data-types>` or "
"a one character typecode of the kind used by the :mod:`array` module with "
"the exception of ``'w'``, which is not supported.  In addition, the ``'c'`` "
"typecode is an alias for :class:`ctypes.c_char`.  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 ""

#: ../../library/multiprocessing.rst:1706
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 ""

#: ../../library/multiprocessing.rst:1713
msgid "Note that *lock* is a keyword only argument."
msgstr ""

#: ../../library/multiprocessing.rst:1715
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 ""

#: ../../library/multiprocessing.rst:1720
msgid "The :mod:`!multiprocessing.sharedctypes` module"
msgstr ":mod:`!multiprocessing.sharedctypes` 模組"

#: ../../library/multiprocessing.rst:1725
msgid ""
"The :mod:`!multiprocessing.sharedctypes` module provides functions for "
"allocating :mod:`ctypes` objects from shared memory which can be inherited "
"by child processes."
msgstr ""

#: ../../library/multiprocessing.rst:1731
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 ""

#: ../../library/multiprocessing.rst:1739
msgid "Return a ctypes array allocated from shared memory."
msgstr ""

#: ../../library/multiprocessing.rst:1741
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 ""

#: ../../library/multiprocessing.rst:1748
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 ""

#: ../../library/multiprocessing.rst:1754
msgid "Return a ctypes object allocated from shared memory."
msgstr ""

#: ../../library/multiprocessing.rst:1760
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 ""

#: ../../library/multiprocessing.rst:1764
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 ""

#: ../../library/multiprocessing.rst:1770
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 ""

#: ../../library/multiprocessing.rst:1774
#: ../../library/multiprocessing.rst:1794
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 ""

#: ../../library/multiprocessing.rst:1782
#: ../../library/multiprocessing.rst:1801
#: ../../library/multiprocessing.rst:1818
#: ../../library/multiprocessing.rst:1939
msgid ""
"*ctx* is a context object, or ``None`` (use the current context). If "
"``None``, calling this may set the global start method. See :ref:`global-"
"start-method` for more details."
msgstr ""

#: ../../library/multiprocessing.rst:1786
#: ../../library/multiprocessing.rst:1805
msgid "Note that *lock* and *ctx* are keyword-only parameters."
msgstr ""

#: ../../library/multiprocessing.rst:1790
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 ""

#: ../../library/multiprocessing.rst:1809
msgid ""
"Return a ctypes object allocated from shared memory which is a copy of the "
"ctypes object *obj*."
msgstr ""

#: ../../library/multiprocessing.rst:1814
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 ""

#: ../../library/multiprocessing.rst:1822
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 ""

#: ../../library/multiprocessing.rst:1826
msgid ""
"Note that accessing the ctypes object through the wrapper can be a lot "
"slower than accessing the raw ctypes object."
msgstr ""

#: ../../library/multiprocessing.rst:1829
msgid "Synchronized objects support the :term:`context manager` protocol."
msgstr ""

#: ../../library/multiprocessing.rst:1833
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 ""

#: ../../library/multiprocessing.rst:1838
msgid "ctypes"
msgstr "ctypes"

#: ../../library/multiprocessing.rst:1838
msgid "sharedctypes using type"
msgstr ""

#: ../../library/multiprocessing.rst:1838
msgid "sharedctypes using typecode"
msgstr ""

#: ../../library/multiprocessing.rst:1840
msgid "c_double(2.4)"
msgstr "c_double(2.4)"

#: ../../library/multiprocessing.rst:1840
msgid "RawValue(c_double, 2.4)"
msgstr "RawValue(c_double, 2.4)"

#: ../../library/multiprocessing.rst:1840
msgid "RawValue('d', 2.4)"
msgstr "RawValue('d', 2.4)"

#: ../../library/multiprocessing.rst:1841
msgid "MyStruct(4, 6)"
msgstr "MyStruct(4, 6)"

#: ../../library/multiprocessing.rst:1841
msgid "RawValue(MyStruct, 4, 6)"
msgstr "RawValue(MyStruct, 4, 6)"

#: ../../library/multiprocessing.rst:1842
msgid "(c_short * 7)()"
msgstr "(c_short * 7)()"

#: ../../library/multiprocessing.rst:1842
msgid "RawArray(c_short, 7)"
msgstr "RawArray(c_short, 7)"

#: ../../library/multiprocessing.rst:1842
msgid "RawArray('h', 7)"
msgstr "RawArray('h', 7)"

#: ../../library/multiprocessing.rst:1843
msgid "(c_int * 3)(9, 2, 8)"
msgstr "(c_int * 3)(9, 2, 8)"

#: ../../library/multiprocessing.rst:1843
msgid "RawArray(c_int, (9, 2, 8))"
msgstr "RawArray(c_int, (9, 2, 8))"

#: ../../library/multiprocessing.rst:1843
msgid "RawArray('i', (9, 2, 8))"
msgstr "RawArray('i', (9, 2, 8))"

#: ../../library/multiprocessing.rst:1847
msgid ""
"Below is an example where a number of ctypes objects are modified by a child "
"process::"
msgstr ""

#: ../../library/multiprocessing.rst:1850
msgid ""
"from multiprocessing import Process, Lock\n"
"from multiprocessing.sharedctypes import Value, Array\n"
"from ctypes import Structure, c_double\n"
"\n"
"class Point(Structure):\n"
"    _fields_ = [('x', c_double), ('y', c_double)]\n"
"\n"
"def modify(n, x, s, A):\n"
"    n.value **= 2\n"
"    x.value **= 2\n"
"    s.value = s.value.upper()\n"
"    for a in A:\n"
"        a.x **= 2\n"
"        a.y **= 2\n"
"\n"
"if __name__ == '__main__':\n"
"    lock = Lock()\n"
"\n"
"    n = Value('i', 7)\n"
"    x = Value(c_double, 1.0/3.0, lock=False)\n"
"    s = Array('c', b'hello world', lock=lock)\n"
"    A = Array(Point, [(1.875,-6.25), (-5.75,2.0), (2.375,9.5)], lock=lock)\n"
"\n"
"    p = Process(target=modify, args=(n, x, s, A))\n"
"    p.start()\n"
"    p.join()\n"
"\n"
"    print(n.value)\n"
"    print(x.value)\n"
"    print(s.value)\n"
"    print([(a.x, a.y) for a in A])"
msgstr ""
"from multiprocessing import Process, Lock\n"
"from multiprocessing.sharedctypes import Value, Array\n"
"from ctypes import Structure, c_double\n"
"\n"
"class Point(Structure):\n"
"    _fields_ = [('x', c_double), ('y', c_double)]\n"
"\n"
"def modify(n, x, s, A):\n"
"    n.value **= 2\n"
"    x.value **= 2\n"
"    s.value = s.value.upper()\n"
"    for a in A:\n"
"        a.x **= 2\n"
"        a.y **= 2\n"
"\n"
"if __name__ == '__main__':\n"
"    lock = Lock()\n"
"\n"
"    n = Value('i', 7)\n"
"    x = Value(c_double, 1.0/3.0, lock=False)\n"
"    s = Array('c', b'hello world', lock=lock)\n"
"    A = Array(Point, [(1.875,-6.25), (-5.75,2.0), (2.375,9.5)], lock=lock)\n"
"\n"
"    p = Process(target=modify, args=(n, x, s, A))\n"
"    p.start()\n"
"    p.join()\n"
"\n"
"    print(n.value)\n"
"    print(x.value)\n"
"    print(s.value)\n"
"    print([(a.x, a.y) for a in A])"

#: ../../library/multiprocessing.rst:1885
msgid "The results printed are ::"
msgstr ""

#: ../../library/multiprocessing.rst:1887
msgid ""
"49\n"
"0.1111111111111111\n"
"HELLO WORLD\n"
"[(3.515625, 39.0625), (33.0625, 4.0), (5.640625, 90.25)]"
msgstr ""
"49\n"
"0.1111111111111111\n"
"HELLO WORLD\n"
"[(3.515625, 39.0625), (33.0625, 4.0), (5.640625, 90.25)]"

#: ../../library/multiprocessing.rst:1898
msgid "Managers"
msgstr ""

#: ../../library/multiprocessing.rst:1900
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 ""

#: ../../library/multiprocessing.rst:1909
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 ""

#: ../../library/multiprocessing.rst:1917
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 ""

#: ../../library/multiprocessing.rst:1923
msgid "Create a BaseManager object."
msgstr "建立一個 BaseManager 物件。"

#: ../../library/multiprocessing.rst:1925
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 ""

#: ../../library/multiprocessing.rst:1928
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 ""

#: ../../library/multiprocessing.rst:1931
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 ""

#: ../../library/multiprocessing.rst:1936
msgid ""
"*serializer* must be ``'pickle'`` (use :mod:`pickle` serialization) or "
"``'xmlrpclib'`` (use :mod:`xmlrpc.client` serialization)."
msgstr ""

#: ../../library/multiprocessing.rst:1943
msgid ""
"*shutdown_timeout* is a timeout in seconds used to wait until the process "
"used by the manager completes in the :meth:`shutdown` method. If the "
"shutdown times out, the process is terminated. If terminating the process "
"also times out, the process is killed."
msgstr ""

#: ../../library/multiprocessing.rst:1948
msgid "Added the *shutdown_timeout* parameter."
msgstr "新增 *shutdown_timeout* 參數。"

#: ../../library/multiprocessing.rst:1953
msgid ""
"Start a subprocess to start the manager.  If *initializer* is not ``None`` "
"then the subprocess will call ``initializer(*initargs)`` when it starts."
msgstr ""

#: ../../library/multiprocessing.rst:1958
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 ""

#: ../../library/multiprocessing.rst:1962
msgid ""
">>> from multiprocessing.managers import BaseManager\n"
">>> manager = BaseManager(address=('', 50000), authkey=b'abc')\n"
">>> server = manager.get_server()\n"
">>> server.serve_forever()"
msgstr ""
">>> from multiprocessing.managers import BaseManager\n"
">>> manager = BaseManager(address=('', 50000), authkey=b'abc')\n"
">>> server = manager.get_server()\n"
">>> server.serve_forever()"

#: ../../library/multiprocessing.rst:1967
msgid ":class:`Server` additionally has an :attr:`address` attribute."
msgstr ""

#: ../../library/multiprocessing.rst:1971
msgid "Connect a local manager object to a remote manager process::"
msgstr ""

#: ../../library/multiprocessing.rst:1973
msgid ""
">>> from multiprocessing.managers import BaseManager\n"
">>> m = BaseManager(address=('127.0.0.1', 50000), authkey=b'abc')\n"
">>> m.connect()"
msgstr ""
">>> from multiprocessing.managers import BaseManager\n"
">>> m = BaseManager(address=('127.0.0.1', 50000), authkey=b'abc')\n"
">>> m.connect()"

#: ../../library/multiprocessing.rst:1979
msgid ""
"Stop the process used by the manager.  This is only available if :meth:"
"`start` has been used to start the server process."
msgstr ""

#: ../../library/multiprocessing.rst:1982
msgid "This can be called multiple times."
msgstr ""

#: ../../library/multiprocessing.rst:1986
msgid ""
"A classmethod which can be used for registering a type or callable with the "
"manager class."
msgstr ""

#: ../../library/multiprocessing.rst:1989
msgid ""
"*typeid* is a \"type identifier\" which is used to identify a particular "
"type of shared object.  This must be a string."
msgstr ""

#: ../../library/multiprocessing.rst:1992
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 ""

#: ../../library/multiprocessing.rst:1998
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 ""

#: ../../library/multiprocessing.rst:2002
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 ""

#: ../../library/multiprocessing.rst:2011
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 ""

#: ../../library/multiprocessing.rst:2018
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 ""

#: ../../library/multiprocessing.rst:2022
msgid ":class:`BaseManager` instances also have one read-only property:"
msgstr ""

#: ../../library/multiprocessing.rst:2026
msgid "The address used by the manager."
msgstr ""

#: ../../library/multiprocessing.rst:2028
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 ""

#: ../../library/multiprocessing.rst:2034
msgid ""
"In previous versions :meth:`~contextmanager.__enter__` did not start the "
"manager's server process if it was not already started."
msgstr ""

#: ../../library/multiprocessing.rst:2039
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 ""

#: ../../library/multiprocessing.rst:2043
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 ""

#: ../../library/multiprocessing.rst:2049
msgid ""
"Create a shared :class:`threading.Barrier` object and return a proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2056
msgid ""
"Create a shared :class:`threading.BoundedSemaphore` object and return a "
"proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2061
msgid ""
"Create a shared :class:`threading.Condition` object and return a proxy for "
"it."
msgstr ""

#: ../../library/multiprocessing.rst:2064
msgid ""
"If *lock* is supplied then it should be a proxy for a :class:`threading."
"Lock` or :class:`threading.RLock` object."
msgstr ""

#: ../../library/multiprocessing.rst:2072
msgid ""
"Create a shared :class:`threading.Event` object and return a proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2076
msgid ""
"Create a shared :class:`threading.Lock` object and return a proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2080
msgid "Create a shared :class:`Namespace` object and return a proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2084
msgid "Create a shared :class:`queue.Queue` object and return a proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2088
msgid ""
"Create a shared :class:`threading.RLock` object and return a proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2092
msgid ""
"Create a shared :class:`threading.Semaphore` object and return a proxy for "
"it."
msgstr ""

#: ../../library/multiprocessing.rst:2097
msgid "Create an array and return a proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2101
msgid ""
"Create an object with a writable ``value`` attribute and return a proxy for "
"it."
msgstr ""

#: ../../library/multiprocessing.rst:2108
msgid "Create a shared :class:`dict` object and return a proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2113
msgid "Create a shared :class:`list` object and return a proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2119
msgid "Create a shared :class:`set` object and return a proxy for it."
msgstr ""

#: ../../library/multiprocessing.rst:2121
msgid ":class:`set` support was added."
msgstr "已新增對 :class:`set` 的支援。"

#: ../../library/multiprocessing.rst:2124
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 ""

#: ../../library/multiprocessing.rst:2131
msgid "A type that can register with :class:`SyncManager`."
msgstr ""

#: ../../library/multiprocessing.rst:2133
msgid ""
"A namespace object has no public methods, but does have writable attributes. "
"Its representation shows the values of its attributes."
msgstr ""

#: ../../library/multiprocessing.rst:2136
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 ""

#: ../../library/multiprocessing.rst:2140
msgid ""
">>> mp_context = multiprocessing.get_context('spawn')\n"
">>> manager = mp_context.Manager()\n"
">>> Global = manager.Namespace()\n"
">>> Global.x = 10\n"
">>> Global.y = 'hello'\n"
">>> Global._z = 12.3    # this is an attribute of the proxy\n"
">>> print(Global)\n"
"Namespace(x=10, y='hello')"
msgstr ""

#: ../../library/multiprocessing.rst:2153
msgid "Customized managers"
msgstr ""

#: ../../library/multiprocessing.rst:2155
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 ""

#: ../../library/multiprocessing.rst:2159
msgid ""
"from multiprocessing.managers import BaseManager\n"
"\n"
"class MathsClass:\n"
"    def add(self, x, y):\n"
"        return x + y\n"
"    def mul(self, x, y):\n"
"        return x * y\n"
"\n"
"class MyManager(BaseManager):\n"
"    pass\n"
"\n"
"MyManager.register('Maths', MathsClass)\n"
"\n"
"if __name__ == '__main__':\n"
"    with MyManager() as manager:\n"
"        maths = manager.Maths()\n"
"        print(maths.add(4, 3))         # prints 7\n"
"        print(maths.mul(7, 8))         # prints 56"
msgstr ""
"from multiprocessing.managers import BaseManager\n"
"\n"
"class MathsClass:\n"
"    def add(self, x, y):\n"
"        return x + y\n"
"    def mul(self, x, y):\n"
"        return x * y\n"
"\n"
"class MyManager(BaseManager):\n"
"    pass\n"
"\n"
"MyManager.register('Maths', MathsClass)\n"
"\n"
"if __name__ == '__main__':\n"
"    with MyManager() as manager:\n"
"        maths = manager.Maths()\n"
"        print(maths.add(4, 3))         # 印出 7\n"
"        print(maths.mul(7, 8))         # 印出 56"

#: ../../library/multiprocessing.rst:2180
msgid "Using a remote manager"
msgstr ""

#: ../../library/multiprocessing.rst:2182
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 ""

#: ../../library/multiprocessing.rst:2185
msgid ""
"Running the following commands creates a server for a single shared queue "
"which remote clients can access::"
msgstr ""

#: ../../library/multiprocessing.rst:2188
msgid ""
">>> from multiprocessing.managers import BaseManager\n"
">>> from queue import Queue\n"
">>> queue = Queue()\n"
">>> class QueueManager(BaseManager): pass\n"
">>> QueueManager.register('get_queue', callable=lambda:queue)\n"
">>> m = QueueManager(address=('', 50000), authkey=b'abracadabra')\n"
">>> s = m.get_server()\n"
">>> s.serve_forever()"
msgstr ""
">>> from multiprocessing.managers import BaseManager\n"
">>> from queue import Queue\n"
">>> queue = Queue()\n"
">>> class QueueManager(BaseManager): pass\n"
">>> QueueManager.register('get_queue', callable=lambda:queue)\n"
">>> m = QueueManager(address=('', 50000), authkey=b'abracadabra')\n"
">>> s = m.get_server()\n"
">>> s.serve_forever()"

#: ../../library/multiprocessing.rst:2197
msgid "One client can access the server as follows::"
msgstr ""

#: ../../library/multiprocessing.rst:2199
msgid ""
">>> from multiprocessing.managers import BaseManager\n"
">>> class QueueManager(BaseManager): pass\n"
">>> QueueManager.register('get_queue')\n"
">>> m = QueueManager(address=('foo.bar.org', 50000), "
"authkey=b'abracadabra')\n"
">>> m.connect()\n"
">>> queue = m.get_queue()\n"
">>> queue.put('hello')"
msgstr ""
">>> from multiprocessing.managers import BaseManager\n"
">>> class QueueManager(BaseManager): pass\n"
">>> QueueManager.register('get_queue')\n"
">>> m = QueueManager(address=('foo.bar.org', 50000), "
"authkey=b'abracadabra')\n"
">>> m.connect()\n"
">>> queue = m.get_queue()\n"
">>> queue.put('hello')"

#: ../../library/multiprocessing.rst:2207
msgid "Another client can also use it::"
msgstr ""

#: ../../library/multiprocessing.rst:2209
msgid ""
">>> from multiprocessing.managers import BaseManager\n"
">>> class QueueManager(BaseManager): pass\n"
">>> QueueManager.register('get_queue')\n"
">>> m = QueueManager(address=('foo.bar.org', 50000), "
"authkey=b'abracadabra')\n"
">>> m.connect()\n"
">>> queue = m.get_queue()\n"
">>> queue.get()\n"
"'hello'"
msgstr ""
">>> from multiprocessing.managers import BaseManager\n"
">>> class QueueManager(BaseManager): pass\n"
">>> QueueManager.register('get_queue')\n"
">>> m = QueueManager(address=('foo.bar.org', 50000), "
"authkey=b'abracadabra')\n"
">>> m.connect()\n"
">>> queue = m.get_queue()\n"
">>> queue.get()\n"
"'hello'"

#: ../../library/multiprocessing.rst:2218
msgid ""
"Local processes can also access that queue, using the code from above on the "
"client to access it remotely::"
msgstr ""

#: ../../library/multiprocessing.rst:2221
msgid ""
">>> from multiprocessing import Process, Queue\n"
">>> from multiprocessing.managers import BaseManager\n"
">>> class Worker(Process):\n"
"...     def __init__(self, q):\n"
"...         self.q = q\n"
"...         super().__init__()\n"
"...     def run(self):\n"
"...         self.q.put('local hello')\n"
"...\n"
">>> queue = Queue()\n"
">>> w = Worker(queue)\n"
">>> w.start()\n"
">>> class QueueManager(BaseManager): pass\n"
"...\n"
">>> QueueManager.register('get_queue', callable=lambda: queue)\n"
">>> m = QueueManager(address=('', 50000), authkey=b'abracadabra')\n"
">>> s = m.get_server()\n"
">>> s.serve_forever()"
msgstr ""
">>> from multiprocessing import Process, Queue\n"
">>> from multiprocessing.managers import BaseManager\n"
">>> class Worker(Process):\n"
"...     def __init__(self, q):\n"
"...         self.q = q\n"
"...         super().__init__()\n"
"...     def run(self):\n"
"...         self.q.put('local hello')\n"
"...\n"
">>> queue = Queue()\n"
">>> w = Worker(queue)\n"
">>> w.start()\n"
">>> class QueueManager(BaseManager): pass\n"
"...\n"
">>> QueueManager.register('get_queue', callable=lambda: queue)\n"
">>> m = QueueManager(address=('', 50000), authkey=b'abracadabra')\n"
">>> s = m.get_server()\n"
">>> s.serve_forever()"

#: ../../library/multiprocessing.rst:2243
msgid "Proxy Objects"
msgstr ""

#: ../../library/multiprocessing.rst:2245
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 ""

#: ../../library/multiprocessing.rst:2249
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 ""

#: ../../library/multiprocessing.rst:2253
msgid ""
">>> mp_context = multiprocessing.get_context('spawn')\n"
">>> manager = mp_context.Manager()\n"
">>> l = manager.list([i*i for i in range(10)])\n"
">>> print(l)\n"
"[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
">>> print(repr(l))\n"
"<ListProxy object, typeid 'list' at 0x...>\n"
">>> l[4]\n"
"16\n"
">>> l[2:5]\n"
"[4, 9, 16]"
msgstr ""
">>> mp_context = multiprocessing.get_context('spawn')\n"
">>> manager = mp_context.Manager()\n"
">>> l = manager.list([i*i for i in range(10)])\n"
">>> print(l)\n"
"[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
">>> print(repr(l))\n"
"<ListProxy object, typeid 'list' at 0x...>\n"
">>> l[4]\n"
"16\n"
">>> l[2:5]\n"
"[4, 9, 16]"

#: ../../library/multiprocessing.rst:2267
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 ""

#: ../../library/multiprocessing.rst:2271
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 ""

#: ../../library/multiprocessing.rst:2276
msgid ""
">>> a = manager.list()\n"
">>> b = manager.list()\n"
">>> a.append(b)         # referent of a now contains referent of b\n"
">>> print(a, b)\n"
"[<ListProxy object, typeid 'list' at ...>] []\n"
">>> b.append('hello')\n"
">>> print(a[0], b)\n"
"['hello'] ['hello']"
msgstr ""

#: ../../library/multiprocessing.rst:2287
msgid "Similarly, dict and list proxies may be nested inside one another::"
msgstr ""

#: ../../library/multiprocessing.rst:2289
msgid ""
">>> l_outer = manager.list([ manager.dict() for i in range(2) ])\n"
">>> d_first_inner = l_outer[0]\n"
">>> d_first_inner['a'] = 1\n"
">>> d_first_inner['b'] = 2\n"
">>> l_outer[1]['c'] = 3\n"
">>> l_outer[1]['z'] = 26\n"
">>> print(l_outer[0])\n"
"{'a': 1, 'b': 2}\n"
">>> print(l_outer[1])\n"
"{'c': 3, 'z': 26}"
msgstr ""
">>> l_outer = manager.list([ manager.dict() for i in range(2) ])\n"
">>> d_first_inner = l_outer[0]\n"
">>> d_first_inner['a'] = 1\n"
">>> d_first_inner['b'] = 2\n"
">>> l_outer[1]['c'] = 3\n"
">>> l_outer[1]['z'] = 26\n"
">>> print(l_outer[0])\n"
"{'a': 1, 'b': 2}\n"
">>> print(l_outer[1])\n"
"{'c': 3, 'z': 26}"

#: ../../library/multiprocessing.rst:2300
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 ""

#: ../../library/multiprocessing.rst:2308
msgid ""
"# create a list proxy and append a mutable object (a dictionary)\n"
"lproxy = manager.list()\n"
"lproxy.append({})\n"
"# now mutate the dictionary\n"
"d = lproxy[0]\n"
"d['a'] = 1\n"
"d['b'] = 2\n"
"# at this point, the changes to d are not yet synced, but by\n"
"# updating the dictionary, the proxy is notified of the change\n"
"lproxy[0] = d"
msgstr ""

#: ../../library/multiprocessing.rst:2319
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 ""

#: ../../library/multiprocessing.rst:2325
msgid ""
"The proxy types in :mod:`!multiprocessing` do nothing to support comparisons "
"by value.  So, for instance, we have:"
msgstr ""

#: ../../library/multiprocessing.rst:2328
msgid ""
">>> manager.list([1,2,3]) == [1,2,3]\n"
"False"
msgstr ""
">>> manager.list([1,2,3]) == [1,2,3]\n"
"False"

#: ../../library/multiprocessing.rst:2333
msgid ""
"One should just use a copy of the referent instead when making comparisons."
msgstr ""

#: ../../library/multiprocessing.rst:2337
msgid "Proxy objects are instances of subclasses of :class:`BaseProxy`."
msgstr ""

#: ../../library/multiprocessing.rst:2341
msgid "Call and return the result of a method of the proxy's referent."
msgstr ""

#: ../../library/multiprocessing.rst:2343
msgid ""
"If ``proxy`` is a proxy whose referent is ``obj`` then the expression ::"
msgstr ""

#: ../../library/multiprocessing.rst:2345
msgid "proxy._callmethod(methodname, args, kwds)"
msgstr "proxy._callmethod(methodname, args, kwds)"

#: ../../library/multiprocessing.rst:2347
msgid "will evaluate the expression ::"
msgstr ""

#: ../../library/multiprocessing.rst:2349
msgid "getattr(obj, methodname)(*args, **kwds)"
msgstr "getattr(obj, methodname)(*args, **kwds)"

#: ../../library/multiprocessing.rst:2351
msgid "in the manager's process."
msgstr ""

#: ../../library/multiprocessing.rst:2353
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 ""

#: ../../library/multiprocessing.rst:2357
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 ""

#: ../../library/multiprocessing.rst:2362
msgid ""
"Note in particular that an exception will be raised if *methodname* has not "
"been *exposed*."
msgstr ""

#: ../../library/multiprocessing.rst:2365
msgid "An example of the usage of :meth:`_callmethod`:"
msgstr ""

#: ../../library/multiprocessing.rst:2367
msgid ""
">>> l = manager.list(range(10))\n"
">>> l._callmethod('__len__')\n"
"10\n"
">>> l._callmethod('__getitem__', (slice(2, 7),)) # equivalent to l[2:7]\n"
"[2, 3, 4, 5, 6]\n"
">>> l._callmethod('__getitem__', (20,))          # equivalent to l[20]\n"
"Traceback (most recent call last):\n"
"...\n"
"IndexError: list index out of range"
msgstr ""
">>> l = manager.list(range(10))\n"
">>> l._callmethod('__len__')\n"
"10\n"
">>> l._callmethod('__getitem__', (slice(2, 7),)) # 等價於 l[2:7]\n"
"[2, 3, 4, 5, 6]\n"
">>> l._callmethod('__getitem__', (20,))          # 等價於 l[20]\n"
"Traceback (most recent call last):\n"
"...\n"
"IndexError: list index out of range"

#: ../../library/multiprocessing.rst:2381
msgid "Return a copy of the referent."
msgstr ""

#: ../../library/multiprocessing.rst:2383
msgid "If the referent is unpicklable then this will raise an exception."
msgstr ""

#: ../../library/multiprocessing.rst:2387
msgid "Return a representation of the proxy object."
msgstr ""

#: ../../library/multiprocessing.rst:2391
msgid "Return the representation of the referent."
msgstr ""

#: ../../library/multiprocessing.rst:2395
msgid "Cleanup"
msgstr ""

#: ../../library/multiprocessing.rst:2397
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 ""

#: ../../library/multiprocessing.rst:2400
msgid ""
"A shared object gets deleted from the manager process when there are no "
"longer any proxies referring to it."
msgstr ""

#: ../../library/multiprocessing.rst:2405
msgid "Process Pools"
msgstr ""

#: ../../library/multiprocessing.rst:2410
msgid ""
"One can create a pool of processes which will carry out tasks submitted to "
"it with the :class:`Pool` class."
msgstr ""

#: ../../library/multiprocessing.rst:2415
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 ""

#: ../../library/multiprocessing.rst:2419
msgid ""
"*processes* is the number of worker processes to use.  If *processes* is "
"``None`` then the number returned by :func:`os.process_cpu_count` is used."
msgstr ""

#: ../../library/multiprocessing.rst:2422
#: ../../library/multiprocessing.rst:2988
msgid ""
"If *initializer* is not ``None`` then each worker process will call "
"``initializer(*initargs)`` when it starts."
msgstr ""

#: ../../library/multiprocessing.rst:2425
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 ""

#: ../../library/multiprocessing.rst:2430
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. If ``None``, calling this "
"function will have the side effect of setting the current global start "
"method if it has not been set already. See the :func:`get_context` function."
msgstr ""

#: ../../library/multiprocessing.rst:2438
msgid ""
"Note that the methods of the pool object should only be called by the "
"process which created the pool."
msgstr ""

#: ../../library/multiprocessing.rst:2442
msgid ""
":class:`multiprocessing.pool` objects have internal resources that need to "
"be properly managed (like any other resource) by using the pool as a context "
"manager or by calling :meth:`close` and :meth:`terminate` manually. Failure "
"to do this can lead to the process hanging on finalization."
msgstr ""

#: ../../library/multiprocessing.rst:2447
msgid ""
"Note that it is **not correct** to rely on the garbage collector to destroy "
"the pool as CPython does not assure that the finalizer of the pool will be "
"called (see :meth:`object.__del__` for more information)."
msgstr ""

#: ../../library/multiprocessing.rst:2451
msgid "Added the *maxtasksperchild* parameter."
msgstr "新增 *maxtasksperchild*  參數。"

#: ../../library/multiprocessing.rst:2454
msgid "Added the *context* parameter."
msgstr "新增 *context* 參數。"

#: ../../library/multiprocessing.rst:2457
msgid ""
"*processes* uses :func:`os.process_cpu_count` by default, instead of :func:"
"`os.cpu_count`."
msgstr ""

#: ../../library/multiprocessing.rst:2463
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 "
"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 ""

#: ../../library/multiprocessing.rst:2473
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 ""

#: ../../library/multiprocessing.rst:2480
msgid ""
"A variant of the :meth:`apply` method which returns a :class:"
"`~multiprocessing.pool.AsyncResult` object."
msgstr ""

#: ../../library/multiprocessing.rst:2483
#: ../../library/multiprocessing.rst:2514
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 ""

#: ../../library/multiprocessing.rst:2488
#: ../../library/multiprocessing.rst:2519
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 ""

#: ../../library/multiprocessing.rst:2492
#: ../../library/multiprocessing.rst:2523
msgid ""
"Callbacks should complete immediately since otherwise the thread which "
"handles the results will get blocked."
msgstr ""

#: ../../library/multiprocessing.rst:2497
msgid ""
"A parallel equivalent of the :func:`map` built-in function (it supports only "
"one *iterable* argument though, for multiple iterables see :meth:`starmap`). "
"It blocks until the result is ready."
msgstr ""

#: ../../library/multiprocessing.rst:2501
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 ""

#: ../../library/multiprocessing.rst:2505
msgid ""
"Note that it may cause high memory usage for very long iterables. Consider "
"using :meth:`imap` or :meth:`imap_unordered` with explicit *chunksize* "
"option for better efficiency."
msgstr ""

#: ../../library/multiprocessing.rst:2511
msgid ""
"A variant of the :meth:`.map` method which returns a :class:"
"`~multiprocessing.pool.AsyncResult` object."
msgstr ""

#: ../../library/multiprocessing.rst:2528
msgid "A lazier version of :meth:`.map`."
msgstr ""

#: ../../library/multiprocessing.rst:2530
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 ""

#: ../../library/multiprocessing.rst:2535
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 ""

#: ../../library/multiprocessing.rst:2542
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 ""

#: ../../library/multiprocessing.rst:2548
msgid ""
"Like :meth:`~multiprocessing.pool.Pool.map` except that the elements of the "
"*iterable* are expected to be iterables that are unpacked as arguments."
msgstr ""

#: ../../library/multiprocessing.rst:2552
msgid ""
"Hence an *iterable* of ``[(1,2), (3, 4)]`` results in ``[func(1,2), "
"func(3,4)]``."
msgstr ""

#: ../../library/multiprocessing.rst:2559
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 ""

#: ../../library/multiprocessing.rst:2567
msgid ""
"Prevents any more tasks from being submitted to the pool.  Once all the "
"tasks have been completed the worker processes will exit."
msgstr ""

#: ../../library/multiprocessing.rst:2572
msgid ""
"Stops the worker processes immediately without completing outstanding work.  "
"When the pool object is garbage collected :meth:`terminate` will be called "
"immediately."
msgstr ""

#: ../../library/multiprocessing.rst:2578
msgid ""
"Wait for the worker processes to exit.  One must call :meth:`close` or :meth:"
"`terminate` before using :meth:`join`."
msgstr ""

#: ../../library/multiprocessing.rst:2581
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 ""

#: ../../library/multiprocessing.rst:2589
msgid ""
"The class of the result returned by :meth:`Pool.apply_async` and :meth:`Pool."
"map_async`."
msgstr ""

#: ../../library/multiprocessing.rst:2594
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 ""

#: ../../library/multiprocessing.rst:2601
msgid "Wait until the result is available or until *timeout* seconds pass."
msgstr ""

#: ../../library/multiprocessing.rst:2605
msgid "Return whether the call has completed."
msgstr ""

#: ../../library/multiprocessing.rst:2609
msgid ""
"Return whether the call completed without raising an exception.  Will raise :"
"exc:`ValueError` if the result is not ready."
msgstr ""

#: ../../library/multiprocessing.rst:2612
msgid ""
"If the result is not ready, :exc:`ValueError` is raised instead of :exc:"
"`AssertionError`."
msgstr ""

#: ../../library/multiprocessing.rst:2616
msgid "The following example demonstrates the use of a pool::"
msgstr ""

#: ../../library/multiprocessing.rst:2618
msgid ""
"from multiprocessing import Pool\n"
"import time\n"
"\n"
"def f(x):\n"
"    return x*x\n"
"\n"
"if __name__ == '__main__':\n"
"    with Pool(processes=4) as pool:         # start 4 worker processes\n"
"        result = pool.apply_async(f, (10,)) # evaluate \"f(10)\" "
"asynchronously in a single process\n"
"        print(result.get(timeout=1))        # prints \"100\" unless your "
"computer is *very* slow\n"
"\n"
"        print(pool.map(f, range(10)))       # prints \"[0, 1, 4,..., 81]\"\n"
"\n"
"        it = pool.imap(f, range(10))\n"
"        print(next(it))                     # prints \"0\"\n"
"        print(next(it))                     # prints \"1\"\n"
"        print(it.next(timeout=1))           # prints \"4\" unless your "
"computer is *very* slow\n"
"\n"
"        result = pool.apply_async(time.sleep, (10,))\n"
"        print(result.get(timeout=1))        # raises multiprocessing."
"TimeoutError"
msgstr ""

#: ../../library/multiprocessing.rst:2643
msgid "Listeners and Clients"
msgstr ""

#: ../../library/multiprocessing.rst:2648
msgid ""
"Usually message passing between processes is done using queues or by using :"
"class:`~Connection` objects returned by :func:`~multiprocessing.Pipe`."
msgstr ""

#: ../../library/multiprocessing.rst:2652
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 ""

#: ../../library/multiprocessing.rst:2661
msgid ""
"Send a randomly generated message to the other end of the connection and "
"wait for a reply."
msgstr ""

#: ../../library/multiprocessing.rst:2664
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 ""

#: ../../library/multiprocessing.rst:2670
msgid ""
"Receive a message, calculate the digest of the message using *authkey* as "
"the key, and then send the digest back."
msgstr ""

#: ../../library/multiprocessing.rst:2673
msgid ""
"If a welcome message is not received, then :exc:`~multiprocessing."
"AuthenticationError` is raised."
msgstr ""

#: ../../library/multiprocessing.rst:2678
msgid ""
"Attempt to set up a connection to the listener which is using address "
"*address*, returning a :class:`~Connection`."
msgstr ""

#: ../../library/multiprocessing.rst:2681
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 ""

#: ../../library/multiprocessing.rst:2685
#: ../../library/multiprocessing.rst:2720
msgid ""
"If *authkey* is given and not ``None``, it should be a byte string and will "
"be used as the secret key for an HMAC-based authentication challenge. No "
"authentication is done if *authkey* is ``None``. :exc:`~multiprocessing."
"AuthenticationError` is raised if authentication fails. See :ref:"
"`multiprocessing-auth-keys`."
msgstr ""

#: ../../library/multiprocessing.rst:2693
msgid ""
"A wrapper for a bound socket or Windows named pipe which is 'listening' for "
"connections."
msgstr ""

#: ../../library/multiprocessing.rst:2696
msgid ""
"*address* is the address to be used by the bound socket or named pipe of the "
"listener object."
msgstr ""

#: ../../library/multiprocessing.rst:2701
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 ""

#: ../../library/multiprocessing.rst:2705
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 ""

#: ../../library/multiprocessing.rst:2716
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 ""

#: ../../library/multiprocessing.rst:2728
msgid ""
"Accept a connection on the bound socket or named pipe of the listener object "
"and return a :class:`~Connection` object. If authentication is attempted and "
"fails, then :exc:`~multiprocessing.AuthenticationError` is raised."
msgstr ""

#: ../../library/multiprocessing.rst:2735
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 ""

#: ../../library/multiprocessing.rst:2739
msgid "Listener objects have the following read-only properties:"
msgstr ""

#: ../../library/multiprocessing.rst:2743
msgid "The address which is being used by the Listener object."
msgstr ""

#: ../../library/multiprocessing.rst:2747
msgid ""
"The address from which the last accepted connection came.  If this is "
"unavailable then it is ``None``."
msgstr ""

#: ../../library/multiprocessing.rst:2750
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 ""

#: ../../library/multiprocessing.rst:2757
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 ""

#: ../../library/multiprocessing.rst:2763
msgid ""
"For both POSIX and Windows, an object can appear in *object_list* if it is"
msgstr ""

#: ../../library/multiprocessing.rst:2766
msgid "a readable :class:`~multiprocessing.connection.Connection` object;"
msgstr ""

#: ../../library/multiprocessing.rst:2767
msgid "a connected and readable :class:`socket.socket` object; or"
msgstr ""

#: ../../library/multiprocessing.rst:2768
msgid ""
"the :attr:`~multiprocessing.Process.sentinel` attribute of a :class:"
"`~multiprocessing.Process` object."
msgstr ""

#: ../../library/multiprocessing.rst:2771
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 ""

#: ../../library/multiprocessing.rst:2774
msgid ""
"**POSIX**: ``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 ""

#: ../../library/multiprocessing.rst:2780
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:`~io.IOBase.fileno` method which returns a socket handle or pipe "
"handle.  (Note that pipe handles and socket handles are **not** waitable "
"handles.)"
msgstr ""

#: ../../library/multiprocessing.rst:2790
msgid "**Examples**"
msgstr ""

#: ../../library/multiprocessing.rst:2792
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 ""

#: ../../library/multiprocessing.rst:2796
msgid ""
"from multiprocessing.connection import Listener\n"
"from array import array\n"
"\n"
"address = ('localhost', 6000)     # family is deduced to be 'AF_INET'\n"
"\n"
"with Listener(address, authkey=b'secret password') as listener:\n"
"    with listener.accept() as conn:\n"
"        print('connection accepted from', listener.last_accepted)\n"
"\n"
"        conn.send([2.25, None, 'junk', float])\n"
"\n"
"        conn.send_bytes(b'hello')\n"
"\n"
"        conn.send_bytes(array('i', [42, 1729]))"
msgstr ""

#: ../../library/multiprocessing.rst:2811
msgid ""
"The following code connects to the server and receives some data from the "
"server::"
msgstr ""

#: ../../library/multiprocessing.rst:2814
msgid ""
"from multiprocessing.connection import Client\n"
"from array import array\n"
"\n"
"address = ('localhost', 6000)\n"
"\n"
"with Client(address, authkey=b'secret password') as conn:\n"
"    print(conn.recv())                  # => [2.25, None, 'junk', float]\n"
"\n"
"    print(conn.recv_bytes())            # => 'hello'\n"
"\n"
"    arr = array('i', [0, 0, 0, 0, 0])\n"
"    print(conn.recv_bytes_into(arr))    # => 8\n"
"    print(arr)                          # => array('i', [42, 1729, 0, 0, 0])"
msgstr ""
"from multiprocessing.connection import Client\n"
"from array import array\n"
"\n"
"address = ('localhost', 6000)\n"
"\n"
"with Client(address, authkey=b'secret password') as conn:\n"
"    print(conn.recv())                  # => [2.25, None, 'junk', float]\n"
"\n"
"    print(conn.recv_bytes())            # => 'hello'\n"
"\n"
"    arr = array('i', [0, 0, 0, 0, 0])\n"
"    print(conn.recv_bytes_into(arr))    # => 8\n"
"    print(arr)                          # => array('i', [42, 1729, 0, 0, 0])"

#: ../../library/multiprocessing.rst:2828
msgid ""
"The following code uses :func:`~multiprocessing.connection.wait` to wait for "
"messages from multiple processes at once::"
msgstr ""

#: ../../library/multiprocessing.rst:2831
msgid ""
"from multiprocessing import Process, Pipe, current_process\n"
"from multiprocessing.connection import wait\n"
"\n"
"def foo(w):\n"
"    for i in range(10):\n"
"        w.send((i, current_process().name))\n"
"    w.close()\n"
"\n"
"if __name__ == '__main__':\n"
"    readers = []\n"
"\n"
"    for i in range(4):\n"
"        r, w = Pipe(duplex=False)\n"
"        readers.append(r)\n"
"        p = Process(target=foo, args=(w,))\n"
"        p.start()\n"
"        # We close the writable end of the pipe now to be sure that\n"
"        # p is the only process which owns a handle for it.  This\n"
"        # ensures that when p closes its handle for the writable end,\n"
"        # wait() will promptly report the readable end as being ready.\n"
"        w.close()\n"
"\n"
"    while readers:\n"
"        for r in wait(readers):\n"
"            try:\n"
"                msg = r.recv()\n"
"            except EOFError:\n"
"                readers.remove(r)\n"
"            else:\n"
"                print(msg)"
msgstr ""

#: ../../library/multiprocessing.rst:2866
msgid "Address Formats"
msgstr ""

#: ../../library/multiprocessing.rst:2868
msgid ""
"An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where "
"*hostname* is a string and *port* is an integer."
msgstr ""

#: ../../library/multiprocessing.rst:2871
msgid ""
"An ``'AF_UNIX'`` address is a string representing a filename on the "
"filesystem."
msgstr ""

#: ../../library/multiprocessing.rst:2874
msgid ""
"An ``'AF_PIPE'`` address is a string of the form :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 ""

#: ../../library/multiprocessing.rst:2879
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 ""

#: ../../library/multiprocessing.rst:2886
msgid "Authentication keys"
msgstr ""

#: ../../library/multiprocessing.rst:2888
msgid ""
"When one uses :meth:`Connection.recv <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 ""

#: ../../library/multiprocessing.rst:2894
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 ""

#: ../../library/multiprocessing.rst:2900
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 ""

#: ../../library/multiprocessing.rst:2908
msgid ""
"Suitable authentication keys can also be generated by using :func:`os."
"urandom`."
msgstr ""

#: ../../library/multiprocessing.rst:2912
msgid "Logging"
msgstr ""

#: ../../library/multiprocessing.rst:2914
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 ""

#: ../../library/multiprocessing.rst:2921
msgid ""
"Returns the logger used by :mod:`!multiprocessing`.  If necessary, a new one "
"will be created."
msgstr ""

#: ../../library/multiprocessing.rst:2924
msgid ""
"When first created the logger has level :const:`logging.NOTSET` and no "
"default handler. Messages sent to this logger will not by default propagate "
"to the root logger."
msgstr ""

#: ../../library/multiprocessing.rst:2928
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 ""

#: ../../library/multiprocessing.rst:2935
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'``. You can modify ``levelname`` of the logger by passing a "
"``level`` argument."
msgstr ""

#: ../../library/multiprocessing.rst:2941
msgid "Below is an example session with logging turned on::"
msgstr ""

#: ../../library/multiprocessing.rst:2943
msgid ""
">>> import multiprocessing, logging\n"
">>> logger = multiprocessing.log_to_stderr()\n"
">>> logger.setLevel(logging.INFO)\n"
">>> logger.warning('doomed')\n"
"[WARNING/MainProcess] doomed\n"
">>> m = multiprocessing.Manager()\n"
"[INFO/SyncManager-...] child process calling self.run()\n"
"[INFO/SyncManager-...] created temp directory /.../pymp-...\n"
"[INFO/SyncManager-...] manager serving at '/.../listener-...'\n"
">>> del m\n"
"[INFO/MainProcess] sending shutdown message to manager\n"
"[INFO/SyncManager-...] manager exiting with exitcode 0"
msgstr ""
">>> import multiprocessing, logging\n"
">>> logger = multiprocessing.log_to_stderr()\n"
">>> logger.setLevel(logging.INFO)\n"
">>> logger.warning('doomed')\n"
"[WARNING/MainProcess] doomed\n"
">>> m = multiprocessing.Manager()\n"
"[INFO/SyncManager-...] child process calling self.run()\n"
"[INFO/SyncManager-...] created temp directory /.../pymp-...\n"
"[INFO/SyncManager-...] manager serving at '/.../listener-...'\n"
">>> del m\n"
"[INFO/MainProcess] sending shutdown message to manager\n"
"[INFO/SyncManager-...] manager exiting with exitcode 0"

#: ../../library/multiprocessing.rst:2956
msgid "For a full table of logging levels, see the :mod:`logging` module."
msgstr ""

#: ../../library/multiprocessing.rst:2960
msgid "The :mod:`!multiprocessing.dummy` module"
msgstr ":mod:`!multiprocessing.dummy` 模組"

#: ../../library/multiprocessing.rst:2965
msgid ""
":mod:`!multiprocessing.dummy` replicates the API of :mod:`!multiprocessing` "
"but is no more than a wrapper around the :mod:`threading` module."
msgstr ""

#: ../../library/multiprocessing.rst:2970
msgid ""
"In particular, the ``Pool`` function provided by :mod:`!multiprocessing."
"dummy` returns an instance of :class:`ThreadPool`, which is a subclass of :"
"class:`Pool` that supports all the same method calls but uses a pool of "
"worker threads rather than worker processes."
msgstr ""

#: ../../library/multiprocessing.rst:2978
msgid ""
"A thread pool object which controls a pool of worker threads to which jobs "
"can be submitted.  :class:`ThreadPool` instances are fully interface "
"compatible with :class:`Pool` instances, and their resources must also be "
"properly managed, either by using the pool as a context manager or by "
"calling :meth:`~multiprocessing.pool.Pool.close` and :meth:`~multiprocessing."
"pool.Pool.terminate` manually."
msgstr ""

#: ../../library/multiprocessing.rst:2985
msgid ""
"*processes* is the number of worker threads to use.  If *processes* is "
"``None`` then the number returned by :func:`os.process_cpu_count` is used."
msgstr ""

#: ../../library/multiprocessing.rst:2991
msgid ""
"Unlike :class:`Pool`, *maxtasksperchild* and *context* cannot be provided."
msgstr ""

#: ../../library/multiprocessing.rst:2995
msgid ""
"A :class:`ThreadPool` shares the same interface as :class:`Pool`, which is "
"designed around a pool of processes and predates the introduction of the :"
"class:`concurrent.futures` module.  As such, it inherits some operations "
"that don't make sense for a pool backed by threads, and it has its own type "
"for representing the status of asynchronous jobs, :class:`AsyncResult`, that "
"is not understood by any other libraries."
msgstr ""

#: ../../library/multiprocessing.rst:3002
msgid ""
"Users should generally prefer to use :class:`concurrent.futures."
"ThreadPoolExecutor`, which has a simpler interface that was designed around "
"threads from the start, and which returns :class:`concurrent.futures.Future` "
"instances that are compatible with many other libraries, including :mod:"
"`asyncio`."
msgstr ""

#: ../../library/multiprocessing.rst:3012
msgid "Programming guidelines"
msgstr ""

#: ../../library/multiprocessing.rst:3014
msgid ""
"There are certain guidelines and idioms which should be adhered to when "
"using :mod:`!multiprocessing`."
msgstr ""

#: ../../library/multiprocessing.rst:3019
msgid "All start methods"
msgstr ""

#: ../../library/multiprocessing.rst:3021
msgid "The following applies to all start methods."
msgstr ""

#: ../../library/multiprocessing.rst:3023
msgid "Avoid shared state"
msgstr ""

#: ../../library/multiprocessing.rst:3025
msgid ""
"As far as possible one should try to avoid shifting large amounts of data "
"between processes."
msgstr ""

#: ../../library/multiprocessing.rst:3028
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 ""

#: ../../library/multiprocessing.rst:3032
msgid "Picklability"
msgstr ""

#: ../../library/multiprocessing.rst:3034
msgid "Ensure that the arguments to the methods of proxies are picklable."
msgstr ""

#: ../../library/multiprocessing.rst:3036
msgid "Thread safety of proxies"
msgstr ""

#: ../../library/multiprocessing.rst:3038
msgid ""
"Do not use a proxy object from more than one thread unless you protect it "
"with a lock."
msgstr ""

#: ../../library/multiprocessing.rst:3041
msgid ""
"(There is never a problem with different processes using the *same* proxy.)"
msgstr ""

#: ../../library/multiprocessing.rst:3043
msgid "Joining zombie processes"
msgstr ""

#: ../../library/multiprocessing.rst:3045
msgid ""
"On POSIX 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 ""

#: ../../library/multiprocessing.rst:3053
msgid "Better to inherit than pickle/unpickle"
msgstr ""

#: ../../library/multiprocessing.rst:3055
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 ""

#: ../../library/multiprocessing.rst:3063
msgid "Avoid terminating processes"
msgstr ""

#: ../../library/multiprocessing.rst:3065
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 ""

#: ../../library/multiprocessing.rst:3071
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 ""

#: ../../library/multiprocessing.rst:3075
msgid "Joining processes that use queues"
msgstr ""

#: ../../library/multiprocessing.rst:3077
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 ""

#: ../../library/multiprocessing.rst:3083
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 ""

#: ../../library/multiprocessing.rst:3089
msgid "An example which will deadlock is the following::"
msgstr ""

#: ../../library/multiprocessing.rst:3091
msgid ""
"from multiprocessing import Process, Queue\n"
"\n"
"def f(q):\n"
"    q.put('X' * 1000000)\n"
"\n"
"if __name__ == '__main__':\n"
"    queue = Queue()\n"
"    p = Process(target=f, args=(queue,))\n"
"    p.start()\n"
"    p.join()                    # this deadlocks\n"
"    obj = queue.get()"
msgstr ""

#: ../../library/multiprocessing.rst:3103
msgid ""
"A fix here would be to swap the last two lines (or simply remove the ``p."
"join()`` line)."
msgstr ""

#: ../../library/multiprocessing.rst:3106
msgid "Explicitly pass resources to child processes"
msgstr ""

#: ../../library/multiprocessing.rst:3108
msgid ""
"On POSIX 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 ""

#: ../../library/multiprocessing.rst:3113
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 ""

#: ../../library/multiprocessing.rst:3120
msgid "So for instance ::"
msgstr ""

#: ../../library/multiprocessing.rst:3122
msgid ""
"from multiprocessing import Process, Lock\n"
"\n"
"def f():\n"
"    ... do something using \"lock\" ...\n"
"\n"
"if __name__ == '__main__':\n"
"    lock = Lock()\n"
"    for i in range(10):\n"
"        Process(target=f).start()"
msgstr ""
"from multiprocessing import Process, Lock\n"
"\n"
"def f():\n"
"    ... do something using \"lock\" ...\n"
"\n"
"if __name__ == '__main__':\n"
"    lock = Lock()\n"
"    for i in range(10):\n"
"        Process(target=f).start()"

#: ../../library/multiprocessing.rst:3132
msgid "should be rewritten as ::"
msgstr ""

#: ../../library/multiprocessing.rst:3134
msgid ""
"from multiprocessing import Process, Lock\n"
"\n"
"def f(l):\n"
"    ... do something using \"l\" ...\n"
"\n"
"if __name__ == '__main__':\n"
"    lock = Lock()\n"
"    for i in range(10):\n"
"        Process(target=f, args=(lock,)).start()"
msgstr ""
"from multiprocessing import Process, Lock\n"
"\n"
"def f(l):\n"
"    ... do something using \"l\" ...\n"
"\n"
"if __name__ == '__main__':\n"
"    lock = Lock()\n"
"    for i in range(10):\n"
"        Process(target=f, args=(lock,)).start()"

#: ../../library/multiprocessing.rst:3144
msgid "Beware of replacing :data:`sys.stdin` with a \"file like object\""
msgstr ""

#: ../../library/multiprocessing.rst:3146
msgid ":mod:`!multiprocessing` originally unconditionally called::"
msgstr ""

#: ../../library/multiprocessing.rst:3148
msgid "os.close(sys.stdin.fileno())"
msgstr "os.close(sys.stdin.fileno())"

#: ../../library/multiprocessing.rst:3150
msgid ""
"in the :meth:`multiprocessing.Process._bootstrap` method --- this resulted "
"in issues with processes-in-processes. This has been changed to::"
msgstr ""

#: ../../library/multiprocessing.rst:3153
msgid ""
"sys.stdin.close()\n"
"sys.stdin = open(os.open(os.devnull, os.O_RDONLY), closefd=False)"
msgstr ""
"sys.stdin.close()\n"
"sys.stdin = open(os.open(os.devnull, os.O_RDONLY), closefd=False)"

#: ../../library/multiprocessing.rst:3156
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 ""

#: ../../library/multiprocessing.rst:3163
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 ""

#: ../../library/multiprocessing.rst:3167
msgid ""
"@property\n"
"def cache(self):\n"
"    pid = os.getpid()\n"
"    if pid != self._pid:\n"
"        self._pid = pid\n"
"        self._cache = []\n"
"    return self._cache"
msgstr ""
"@property\n"
"def cache(self):\n"
"    pid = os.getpid()\n"
"    if pid != self._pid:\n"
"        self._pid = pid\n"
"        self._cache = []\n"
"    return self._cache"

#: ../../library/multiprocessing.rst:3175
msgid ""
"For more information, see :issue:`5155`, :issue:`5313` and :issue:`5331`"
msgstr ""

#: ../../library/multiprocessing.rst:3181
msgid "The *spawn* and *forkserver* start methods"
msgstr ""

#: ../../library/multiprocessing.rst:3183
msgid ""
"There are a few extra restrictions which don't apply to the *fork* start "
"method."
msgstr ""

#: ../../library/multiprocessing.rst:3186
msgid "More picklability"
msgstr ""

#: ../../library/multiprocessing.rst:3188
msgid ""
"Ensure that all arguments to :class:`~multiprocessing.Process` are "
"picklable.  Also, if you subclass ``Process.__init__``, you must make sure "
"that instances will be picklable when the :meth:`Process.start "
"<multiprocessing.Process.start>` method is called."
msgstr ""

#: ../../library/multiprocessing.rst:3193
msgid "Global variables"
msgstr ""

#: ../../library/multiprocessing.rst:3195
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 ""

#: ../../library/multiprocessing.rst:3200
msgid ""
"However, global variables which are just module level constants cause no "
"problems."
msgstr ""

#: ../../library/multiprocessing.rst:3205
msgid "Safe importing of main module"
msgstr ""

#: ../../library/multiprocessing.rst:3207
msgid ""
"Make sure that the main module can be safely imported by a new Python "
"interpreter without causing unintended side effects (such as starting a new "
"process)."
msgstr ""

#: ../../library/multiprocessing.rst:3211
msgid ""
"For example, using the *spawn* or *forkserver* start method running the "
"following module would fail with a :exc:`RuntimeError`::"
msgstr ""

#: ../../library/multiprocessing.rst:3215
msgid ""
"from multiprocessing import Process\n"
"\n"
"def foo():\n"
"    print('hello')\n"
"\n"
"p = Process(target=foo)\n"
"p.start()"
msgstr ""
"from multiprocessing import Process\n"
"\n"
"def foo():\n"
"    print('hello')\n"
"\n"
"p = Process(target=foo)\n"
"p.start()"

#: ../../library/multiprocessing.rst:3223
msgid ""
"Instead one should protect the \"entry point\" of the program by using ``if "
"__name__ == '__main__':`` as follows::"
msgstr ""

#: ../../library/multiprocessing.rst:3226
msgid ""
"from multiprocessing import Process, freeze_support, set_start_method\n"
"\n"
"def foo():\n"
"    print('hello')\n"
"\n"
"if __name__ == '__main__':\n"
"    freeze_support()\n"
"    set_start_method('spawn')\n"
"    p = Process(target=foo)\n"
"    p.start()"
msgstr ""
"from multiprocessing import Process, freeze_support, set_start_method\n"
"\n"
"def foo():\n"
"    print('hello')\n"
"\n"
"if __name__ == '__main__':\n"
"    freeze_support()\n"
"    set_start_method('spawn')\n"
"    p = Process(target=foo)\n"
"    p.start()"

#: ../../library/multiprocessing.rst:3237
msgid ""
"(The ``freeze_support()`` line can be omitted if the program will be run "
"normally instead of frozen.)"
msgstr ""

#: ../../library/multiprocessing.rst:3240
msgid ""
"This allows the newly spawned Python interpreter to safely import the module "
"and then run the module's ``foo()`` function."
msgstr ""

#: ../../library/multiprocessing.rst:3243
msgid ""
"Similar restrictions apply if a pool or manager is created in the main "
"module."
msgstr ""

#: ../../library/multiprocessing.rst:3250
msgid "Examples"
msgstr "範例"

#: ../../library/multiprocessing.rst:3252
msgid "Demonstration of how to create and use customized managers and proxies:"
msgstr ""

#: ../../library/multiprocessing.rst:3254
msgid ""
"from multiprocessing import freeze_support\n"
"from multiprocessing.managers import BaseManager, BaseProxy\n"
"import operator\n"
"\n"
"##\n"
"\n"
"class Foo:\n"
"    def f(self):\n"
"        print('you called Foo.f()')\n"
"    def g(self):\n"
"        print('you called Foo.g()')\n"
"    def _h(self):\n"
"        print('you called Foo._h()')\n"
"\n"
"# A simple generator function\n"
"def baz():\n"
"    for i in range(10):\n"
"        yield i*i\n"
"\n"
"# Proxy type for generator objects\n"
"class GeneratorProxy(BaseProxy):\n"
"    _exposed_ = ['__next__']\n"
"    def __iter__(self):\n"
"        return self\n"
"    def __next__(self):\n"
"        return self._callmethod('__next__')\n"
"\n"
"# Function to return the operator module\n"
"def get_operator_module():\n"
"    return operator\n"
"\n"
"##\n"
"\n"
"class MyManager(BaseManager):\n"
"    pass\n"
"\n"
"# register the Foo class; make `f()` and `g()` accessible via proxy\n"
"MyManager.register('Foo1', Foo)\n"
"\n"
"# register the Foo class; make `g()` and `_h()` accessible via proxy\n"
"MyManager.register('Foo2', Foo, exposed=('g', '_h'))\n"
"\n"
"# register the generator function baz; use `GeneratorProxy` to make proxies\n"
"MyManager.register('baz', baz, proxytype=GeneratorProxy)\n"
"\n"
"# register get_operator_module(); make public functions accessible via "
"proxy\n"
"MyManager.register('operator', get_operator_module)\n"
"\n"
"##\n"
"\n"
"def test():\n"
"    manager = MyManager()\n"
"    manager.start()\n"
"\n"
"    print('-' * 20)\n"
"\n"
"    f1 = manager.Foo1()\n"
"    f1.f()\n"
"    f1.g()\n"
"    assert not hasattr(f1, '_h')\n"
"    assert sorted(f1._exposed_) == sorted(['f', 'g'])\n"
"\n"
"    print('-' * 20)\n"
"\n"
"    f2 = manager.Foo2()\n"
"    f2.g()\n"
"    f2._h()\n"
"    assert not hasattr(f2, 'f')\n"
"    assert sorted(f2._exposed_) == sorted(['g', '_h'])\n"
"\n"
"    print('-' * 20)\n"
"\n"
"    it = manager.baz()\n"
"    for i in it:\n"
"        print('<%d>' % i, end=' ')\n"
"    print()\n"
"\n"
"    print('-' * 20)\n"
"\n"
"    op = manager.operator()\n"
"    print('op.add(23, 45) =', op.add(23, 45))\n"
"    print('op.pow(2, 94) =', op.pow(2, 94))\n"
"    print('op._exposed_ =', op._exposed_)\n"
"\n"
"##\n"
"\n"
"if __name__ == '__main__':\n"
"    freeze_support()\n"
"    test()\n"
msgstr ""

#: ../../library/multiprocessing.rst:3258
msgid "Using :class:`~multiprocessing.pool.Pool`:"
msgstr "使用 :class:`~multiprocessing.pool.Pool`："

#: ../../library/multiprocessing.rst:3260
msgid ""
"import multiprocessing\n"
"import time\n"
"import random\n"
"import sys\n"
"\n"
"#\n"
"# Functions used by test code\n"
"#\n"
"\n"
"def calculate(func, args):\n"
"    result = func(*args)\n"
"    return '%s says that %s%s = %s' % (\n"
"        multiprocessing.current_process().name,\n"
"        func.__name__, args, result\n"
"        )\n"
"\n"
"def calculatestar(args):\n"
"    return calculate(*args)\n"
"\n"
"def mul(a, b):\n"
"    time.sleep(0.5 * random.random())\n"
"    return a * b\n"
"\n"
"def plus(a, b):\n"
"    time.sleep(0.5 * random.random())\n"
"    return a + b\n"
"\n"
"def f(x):\n"
"    return 1.0 / (x - 5.0)\n"
"\n"
"def pow3(x):\n"
"    return x ** 3\n"
"\n"
"def noop(x):\n"
"    pass\n"
"\n"
"#\n"
"# Test code\n"
"#\n"
"\n"
"def test():\n"
"    PROCESSES = 4\n"
"    print('Creating pool with %d processes\\n' % PROCESSES)\n"
"\n"
"    with multiprocessing.Pool(PROCESSES) as pool:\n"
"        #\n"
"        # Tests\n"
"        #\n"
"\n"
"        TASKS = [(mul, (i, 7)) for i in range(10)] + \\\n"
"                [(plus, (i, 8)) for i in range(10)]\n"
"\n"
"        results = [pool.apply_async(calculate, t) for t in TASKS]\n"
"        imap_it = pool.imap(calculatestar, TASKS)\n"
"        imap_unordered_it = pool.imap_unordered(calculatestar, TASKS)\n"
"\n"
"        print('Ordered results using pool.apply_async():')\n"
"        for r in results:\n"
"            print('\\t', r.get())\n"
"        print()\n"
"\n"
"        print('Ordered results using pool.imap():')\n"
"        for x in imap_it:\n"
"            print('\\t', x)\n"
"        print()\n"
"\n"
"        print('Unordered results using pool.imap_unordered():')\n"
"        for x in imap_unordered_it:\n"
"            print('\\t', x)\n"
"        print()\n"
"\n"
"        print('Ordered results using pool.map() --- will block till "
"complete:')\n"
"        for x in pool.map(calculatestar, TASKS):\n"
"            print('\\t', x)\n"
"        print()\n"
"\n"
"        #\n"
"        # Test error handling\n"
"        #\n"
"\n"
"        print('Testing error handling:')\n"
"\n"
"        try:\n"
"            print(pool.apply(f, (5,)))\n"
"        except ZeroDivisionError:\n"
"            print('\\tGot ZeroDivisionError as expected from pool.apply()')\n"
"        else:\n"
"            raise AssertionError('expected ZeroDivisionError')\n"
"\n"
"        try:\n"
"            print(pool.map(f, list(range(10))))\n"
"        except ZeroDivisionError:\n"
"            print('\\tGot ZeroDivisionError as expected from pool.map()')\n"
"        else:\n"
"            raise AssertionError('expected ZeroDivisionError')\n"
"\n"
"        try:\n"
"            print(list(pool.imap(f, list(range(10)))))\n"
"        except ZeroDivisionError:\n"
"            print('\\tGot ZeroDivisionError as expected from list(pool."
"imap())')\n"
"        else:\n"
"            raise AssertionError('expected ZeroDivisionError')\n"
"\n"
"        it = pool.imap(f, list(range(10)))\n"
"        for i in range(10):\n"
"            try:\n"
"                x = next(it)\n"
"            except ZeroDivisionError:\n"
"                if i == 5:\n"
"                    pass\n"
"            except StopIteration:\n"
"                break\n"
"            else:\n"
"                if i == 5:\n"
"                    raise AssertionError('expected ZeroDivisionError')\n"
"\n"
"        assert i == 9\n"
"        print('\\tGot ZeroDivisionError as expected from IMapIterator."
"next()')\n"
"        print()\n"
"\n"
"        #\n"
"        # Testing timeouts\n"
"        #\n"
"\n"
"        print('Testing ApplyResult.get() with timeout:', end=' ')\n"
"        res = pool.apply_async(calculate, TASKS[0])\n"
"        while 1:\n"
"            sys.stdout.flush()\n"
"            try:\n"
"                sys.stdout.write('\\n\\t%s' % res.get(0.02))\n"
"                break\n"
"            except multiprocessing.TimeoutError:\n"
"                sys.stdout.write('.')\n"
"        print()\n"
"        print()\n"
"\n"
"        print('Testing IMapIterator.next() with timeout:', end=' ')\n"
"        it = pool.imap(calculatestar, TASKS)\n"
"        while 1:\n"
"            sys.stdout.flush()\n"
"            try:\n"
"                sys.stdout.write('\\n\\t%s' % it.next(0.02))\n"
"            except StopIteration:\n"
"                break\n"
"            except multiprocessing.TimeoutError:\n"
"                sys.stdout.write('.')\n"
"        print()\n"
"        print()\n"
"\n"
"\n"
"if __name__ == '__main__':\n"
"    multiprocessing.freeze_support()\n"
"    test()\n"
msgstr ""

#: ../../library/multiprocessing.rst:3264
msgid ""
"An example showing how to use queues to feed tasks to a collection of worker "
"processes and collect the results:"
msgstr ""

#: ../../library/multiprocessing.rst:3267
msgid ""
"import time\n"
"import random\n"
"\n"
"from multiprocessing import Process, Queue, current_process, freeze_support\n"
"\n"
"#\n"
"# Function run by worker processes\n"
"#\n"
"\n"
"def worker(input, output):\n"
"    for func, args in iter(input.get, 'STOP'):\n"
"        result = calculate(func, args)\n"
"        output.put(result)\n"
"\n"
"#\n"
"# Function used to calculate result\n"
"#\n"
"\n"
"def calculate(func, args):\n"
"    result = func(*args)\n"
"    return '%s says that %s%s = %s' % \\\n"
"        (current_process().name, func.__name__, args, result)\n"
"\n"
"#\n"
"# Functions referenced by tasks\n"
"#\n"
"\n"
"def mul(a, b):\n"
"    time.sleep(0.5*random.random())\n"
"    return a * b\n"
"\n"
"def plus(a, b):\n"
"    time.sleep(0.5*random.random())\n"
"    return a + b\n"
"\n"
"#\n"
"#\n"
"#\n"
"\n"
"def test():\n"
"    NUMBER_OF_PROCESSES = 4\n"
"    TASKS1 = [(mul, (i, 7)) for i in range(20)]\n"
"    TASKS2 = [(plus, (i, 8)) for i in range(10)]\n"
"\n"
"    # Create queues\n"
"    task_queue = Queue()\n"
"    done_queue = Queue()\n"
"\n"
"    # Submit tasks\n"
"    for task in TASKS1:\n"
"        task_queue.put(task)\n"
"\n"
"    # Start worker processes\n"
"    for i in range(NUMBER_OF_PROCESSES):\n"
"        Process(target=worker, args=(task_queue, done_queue)).start()\n"
"\n"
"    # Get and print results\n"
"    print('Unordered results:')\n"
"    for i in range(len(TASKS1)):\n"
"        print('\\t', done_queue.get())\n"
"\n"
"    # Add more tasks using `put()`\n"
"    for task in TASKS2:\n"
"        task_queue.put(task)\n"
"\n"
"    # Get and print some more results\n"
"    for i in range(len(TASKS2)):\n"
"        print('\\t', done_queue.get())\n"
"\n"
"    # Tell child processes to stop\n"
"    for i in range(NUMBER_OF_PROCESSES):\n"
"        task_queue.put('STOP')\n"
"\n"
"\n"
"if __name__ == '__main__':\n"
"    freeze_support()\n"
"    test()\n"
msgstr ""