• R/O
  • SSH
  • HTTPS

pythonjp: Commit


Commit MetaInfo

Révision534 (tree)
l'heure2010-11-22 01:48:00
Auteurtosikawa

Message de Log

2.6.2 新規翻訳: もりもと さん

Change Summary

Modification

--- Doc/trunk/library/multiprocessing.rst (revision 533)
+++ Doc/trunk/library/multiprocessing.rst (revision 534)
@@ -1,5 +1,5 @@
1-:mod:`multiprocessing` --- Process-based "threading" interface
2-==============================================================
1+:mod:`multiprocessing` --- プロセスベースの "並列処理" インタフェース
2+=====================================================================
33
44 .. module:: multiprocessing
55 :synopsis: Process-based "threading" interface.
@@ -7,79 +7,131 @@
77 .. versionadded:: 2.6
88
99
10-Introduction
11-----------------------
10+はじめに
11+--------
1212
13-:mod:`multiprocessing` is a package that supports spawning processes using an
14-API similar to the :mod:`threading` module. The :mod:`multiprocessing` package
15-offers both local and remote concurrency, effectively side-stepping the
16-:term:`Global Interpreter Lock` by using subprocesses instead of threads. Due
17-to this, the :mod:`multiprocessing` module allows the programmer to fully
18-leverage multiple processors on a given machine. It runs on both Unix and
19-Windows.
13+:mod:`multiprocessing` はPythonの標準ライブラリのパッケージで
14+:mod:`threading` とよく似た API を使ってプロセスを生成することができます。
15+:mod:`multiprocessing` パッケージを使用すると、
16+ローカルとリモート両方の並列制御を行うことができます。
17+また、このパッケージはスレッドの代わりにサブプロセスを使用することにより、
18+グローバルインタプリタロック ( :term:`Global Interpreter Lock` )
19+の問題を避ける工夫が行われています。
20+このような特徴があるため :mod:`multiprocessing` モジュールを使うことで、
21+マルチプロセッサマシンの性能を最大限に活用することができるでしょう。
22+なお、このモジュールは Unix と Windows で動作します。
2023
2124 .. warning::
2225
23- Some of this package's functionality requires a functioning shared semaphore
24- implementation on the host operating system. Without one, the
25- :mod:`multiprocessing.synchronize` module will be disabled, and attempts to
26- import it will result in an :exc:`ImportError`. See
27- :issue:`3770` for additional information.
26+ このパッケージに含まれる機能には、ホストとなるオペレーティングシステム上で
27+ 動作している共有セマフォ (shared semaphore) を使用しているものがあります。
28+ これが使用できない場合には、 :mod:`multiprocessing.synchronize` モジュールが無効になり、
29+ このモジュールのインポート時に :exc:`ImportError` が発生します。
30+ 詳細は :issue:`3770` を参照してください。
2831
29-The :class:`Process` class
32+.. note::
33+
34+ このパッケージに含まれる機能を使用するためには、子プロセスから
35+ ``__main__`` メソッドを呼び出せる必要があります。
36+ このことについては :ref:`multiprocessing-programming` で触れていますが、
37+ ここであらためて強調しておきます。何故かというと、いくつかのサンプルコード、例えば
38+ :class:`multiprocessing.Pool` のサンプルはインタラクティブシェル上では動作しないからです。
39+ 以下に例を示します。 ::
40+
41+ >>> from multiprocessing import Pool
42+ >>> p = Pool(5)
43+ >>> def f(x):
44+ ... return x*x
45+ ...
46+ >>> p.map(f, [1,2,3])
47+ Process PoolWorker-1:
48+ Process PoolWorker-2:
49+ Traceback (most recent call last):
50+ Traceback (most recent call last):
51+ AttributeError: 'module' object has no attribute 'f'
52+ AttributeError: 'module' object has no attribute 'f'
53+ AttributeError: 'module' object has no attribute 'f'
54+
55+
56+:class:`Process` クラス
3057 ~~~~~~~~~~~~~~~~~~~~~~~~~~
3158
32-In :mod:`multiprocessing`, processes are spawned by creating a :class:`Process`
33-object and then calling its :meth:`~Process.start` method. :class:`Process`
34-follows the API of :class:`threading.Thread`. A trivial example of a
35-multiprocess program is ::
59+:mod:`multiprocessing` モジュールでは、プロセスは以下の手順によって生成されます。
60+はじめに :class:`Process` のオブジェクトを作成し、
61+続いて :meth:`~Process.start` メソッドを呼び出します。
62+この :class:`Process` クラスは :class:`threading.Thread` クラスと同様の API を持っています。
63+まずは、簡単な例をもとにマルチプロセスを使用したプログラムについてみていきましょう。
3664
37- from multiprocessing import Process
65+::
3866
39- def f(name):
40- print 'hello', name
67+ from multiprocessing import Process
4168
42- if __name__ == '__main__':
43- p = Process(target=f, args=('bob',))
44- p.start()
45- p.join()
69+ def f(name):
70+ print 'hello', name
4671
47-Here the function ``f`` is run in a child process.
72+ if __name__ == '__main__':
73+ p = Process(target=f, args=('bob',))
74+ p.start()
75+ p.join()
4876
49-For an explanation of why (on Windows) the ``if __name__ == '__main__'`` part is
50-necessary, see :ref:`multiprocessing-programming`.
77+実行された個々のプロセス ID を表示するために拡張したサンプルコードを以下に例を示します。
5178
79+::
5280
81+ from multiprocessing import Process
82+ import os
5383
54-Exchanging objects between processes
55-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
84+ def info(title):
85+ print title
86+ print 'module name:', __name__
87+ print 'parent process:', os.getppid()
88+ print 'process id:', os.getpid()
5689
57-:mod:`multiprocessing` supports two types of communication channel between
58-processes:
90+ def f(name):
91+ info('function f')
92+ print 'hello', name
5993
60-**Queues**
94+ if __name__ == '__main__':
95+ info('main line')
96+ p = Process(target=f, args=('bob',))
97+ p.start()
98+ p.join()
6199
62- The :class:`Queue` class is a near clone of :class:`Queue.Queue`. For
63- example::
100+(Windows 環境で) ``if __name__ == '__main__'`` という文が必要な理由については、
101+:ref:`multiprocessing-programming` を参照してください。
64102
103+
104+
105+プロセス間でのオブジェクト交換
106+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
107+
108+:mod:`multiprocessing` モジュールでは、プロセス間通信の手段が2つ用意されています。
109+それぞれ以下に詳細を示します。
110+
111+**キュー (Queue)**
112+
113+ :class:`Queue` クラスは :class:`Queue.Queue` クラスとほとんど同じように使うことができます。
114+ 以下に例を示します。 ::
115+
65116 from multiprocessing import Process, Queue
66117
67118 def f(q):
68119 q.put([42, None, 'hello'])
69120
70- if __name__ == '__main__':
71- q = Queue()
72- p = Process(target=f, args=(q,))
73- p.start()
74- print q.get() # prints "[42, None, 'hello']"
75- p.join()
121+ if __name__ == '__main__':
122+ q = Queue()
123+ p = Process(target=f, args=(q,))
124+ p.start()
125+ print q.get() # "[42, None, 'hello']" を表示
126+ p.join()
76127
77- Queues are thread and process safe.
128+ キューはスレッドセーフであり、プロセスセーフです。
78129
79-**Pipes**
130+**パイプ (Pipe)**
80131
81- The :func:`Pipe` function returns a pair of connection objects connected by a
82- pipe which by default is duplex (two-way). For example::
132+ :func:`Pipe` 関数は接続用オブジェクトのペアを返します。デフォルトでは、
133+ このオブジェクトを介して、親子間でパイプを使った双方向通信をおこなうことができます。
134+ 以下に例を示します。 ::
83135
84136 from multiprocessing import Process, Pipe
85137
@@ -91,24 +143,26 @@
91143 parent_conn, child_conn = Pipe()
92144 p = Process(target=f, args=(child_conn,))
93145 p.start()
94- print parent_conn.recv() # prints "[42, None, 'hello']"
146+ print parent_conn.recv() # "[42, None, 'hello']" を表示
95147 p.join()
96148
97- The two connection objects returned by :func:`Pipe` represent the two ends of
98- the pipe. Each connection object has :meth:`~Connection.send` and
99- :meth:`~Connection.recv` methods (among others). Note that data in a pipe
100- may become corrupted if two processes (or threads) try to read from or write
101- to the *same* end of the pipe at the same time. Of course there is no risk
102- of corruption from processes using different ends of the pipe at the same
103- time.
149+ 2つのコネクション用オブジェクトが :func:`Pipe` 関数から返され、
150+ 親側の入出力、子側の入出力といったように、それぞれパイプの両端となります。
151+ (他プロセスと通信する方法として) 各接続用オブジェクトには、
152+ :meth:`~Connection.send` メソッドと :meth:`~Connection.recv` メソッドがあります。
153+ データを破壊してしまうような使い方に注意する必要があります。
154+ それは、2つのプロセス (もしくはスレッド) が同時に *同じ* パイプに対して、
155+ 読み書きをおこなった場合に起こります。
156+ もちろん、異なったパイプを使用していれば、同時に読み書きをおこなっても
157+ データが破壊されてしまう危険性はありません。
104158
105159
106-Synchronization between processes
160+プロセス間の同期
107161 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
108162
109-:mod:`multiprocessing` contains equivalents of all the synchronization
110-primitives from :mod:`threading`. For instance one can use a lock to ensure
111-that only one process prints to standard output at a time::
163+:mod:`multiprocessing` は :mod:`threading` モジュールと同じプロセス間同期の仕組みを
164+備えています。以下の例では、ロックを使用して、一度に1つのプロセスしか
165+標準出力に書き込まないようにしています。 ::
112166
113167 from multiprocessing import Process, Lock
114168
@@ -123,24 +177,25 @@
123177 for num in range(10):
124178 Process(target=f, args=(lock, num)).start()
125179
126-Without using the lock output from the different processes is liable to get all
127-mixed up.
180+ロックを使用しないで標準出力に書き込んだ場合は、
181+各プロセスからの出力がごちゃまぜになってしまいます。
128182
129183
130-Sharing state between processes
131-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
184+プロセス間での状態の共有
185+~~~~~~~~~~~~~~~~~~~~~~~~
132186
133-As mentioned above, when doing concurrent programming it is usually best to
134-avoid using shared state as far as possible. This is particularly true when
135-using multiple processes.
187+これまでの話の流れで触れたとおり、並列プログラミングをする時には、
188+出来る限り状態を共有しないというのが定石です。
189+複数のプロセッサを使用するときは特にそうでしょう。
136190
137-However, if you really do need to use some shared data then
138-:mod:`multiprocessing` provides a couple of ways of doing so.
191+しかし、どうしてもプロセス間のデータ共有が必要な場合のために
192+:mod:`multiprocessing` モジュールにはその方法が用意されています。
139193
140-**Shared memory**
194+**共有メモリ (Shared memory)**
141195
142- Data can be stored in a shared memory map using :class:`Value` or
143- :class:`Array`. For example, the following code ::
196+ データを共有メモリ上に保持するために :class:`Value` クラス、
197+ もしくは :class:`Array` クラスを使用することができます。
198+ 以下のサンプルコードを使って、この機能についてみていきましょう。 ::
144199
145200 from multiprocessing import Process, Value, Array
146201
@@ -160,31 +215,32 @@
160215 print num.value
161216 print arr[:]
162217
163- will print ::
218+ このサンプルコードを実行すると以下のように表示されます。 ::
164219
165220 3.1415927
166221 [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
167222
168- The ``'d'`` and ``'i'`` arguments used when creating ``num`` and ``arr`` are
169- typecodes of the kind used by the :mod:`array` module: ``'d'`` indicates a
170- double precision float and ``'i'`` indicates a signed integer. These shared
171- objects will be process and thread safe.
223+ ``num`` と ``arr`` を生成するときに使用されている ``'d'`` と ``'i'`` の引数は
224+ :mod:`array` モジュールにより使用される種別の型コードです。
225+ ここで使用されている ``'d'`` は倍精度浮動小数、 ``'i'`` は符号付整数を表します。
226+ これらの共有オブジェクトは、プロセスセーフでありスレッドセーフです。
172227
173- For more flexibility in using shared memory one can use the
174- :mod:`multiprocessing.sharedctypes` module which supports the creation of
175- arbitrary ctypes objects allocated from shared memory.
228+ 共有メモリを使用して、さらに柔軟なプログラミングを行うには
229+ :mod:`multiprocessing.sharedctypes` モジュールを使用します。
230+ このモジュールは共有メモリから割り当てられた任意の ctypes オブジェクトの
231+ 生成をサポートします。
176232
177-**Server process**
233+**サーバプロセス (Server process)**
178234
179- A manager object returned by :func:`Manager` controls a server process which
180- holds Python objects and allows other processes to manipulate them using
181- proxies.
235+ :func:`Manager` 関数により生成されたマネージャオブジェクトはサーバプロセスを管理します。
236+ マネージャオブジェクトは Python のオブジェクトを保持して、他のプロセスが
237+ プロキシ経由でその Python オブジェクトを操作することができます。
182238
183- A manager returned by :func:`Manager` will support types :class:`list`,
184- :class:`dict`, :class:`Namespace`, :class:`Lock`, :class:`RLock`,
185- :class:`Semaphore`, :class:`BoundedSemaphore`, :class:`Condition`,
186- :class:`Event`, :class:`Queue`, :class:`Value` and :class:`Array`. For
187- example, ::
239+ :func:`Manager` 関数が返すマネージャは :class:`list` 、 :class:`dict` 、
240+ :class:`Namespace` 、 :class:`Lock` 、 :class:`RLock` 、 :class:`Semaphore` 、
241+ :class:`BoundedSemaphore` 、 :class:`Condition` 、 :class:`Event` 、
242+ :class:`Queue` 、 :class:`Value` 、 :class:`Array` をサポートします。
243+ 以下にサンプルコードを示します。 ::
188244
189245 from multiprocessing import Process, Manager
190246
@@ -207,25 +263,25 @@
207263 print d
208264 print l
209265
210- will print ::
266+ このサンプルコードを実行すると以下のように表示されます。 ::
211267
212268 {0.25: None, 1: '1', '2': 2}
213269 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
214270
215- Server process managers are more flexible than using shared memory objects
216- because they can be made to support arbitrary object types. Also, a single
217- manager can be shared by processes on different computers over a network.
218- They are, however, slower than using shared memory.
271+ サーバプロセスのマネージャオブジェクトは共有メモリのオブジェクトよりも
272+ 柔軟であるといえます。それは、どのような型のオブジェクトでも使えるからです。
273+ また、1つのマネージャオブジェクトはネットワーク経由で他のコンピュータ上の
274+ プロセスによって共有することもできます。
275+ しかし、共有メモリより動作が遅いという欠点があります。
219276
220277
221-Using a pool of workers
222-~~~~~~~~~~~~~~~~~~~~~~~
278+ワーカープロセスのプールを使用
279+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
223280
224-The :class:`~multiprocessing.pool.Pool` class represents a pool of worker
225-processes. It has methods which allows tasks to be offloaded to the worker
226-processes in a few different ways.
281+:class:`~multiprocessing.pool.Pool` クラスは、ワーカープロセスをプールする機能を備えています。
282+このクラスには、いくつかの方法で開放されたワーカープロセスへタスクを割り当てるメソッドがあります。
227283
228-For example::
284+以下に例を示します。 ::
229285
230286 from multiprocessing import Pool
231287
@@ -233,153 +289,149 @@
233289 return x*x
234290
235291 if __name__ == '__main__':
236- pool = Pool(processes=4) # start 4 worker processes
237- result = pool.applyAsync(f, [10]) # evaluate "f(10)" asynchronously
238- print result.get(timeout=1) # prints "100" unless your computer is *very* slow
239- print pool.map(f, range(10)) # prints "[0, 1, 4,..., 81]"
292+ pool = Pool(processes=4) # 4つのワーカープロセスで開始
293+ result = pool.apply_async(f, [10]) # 非同期で "f(10)" を評価
294+ print result.get(timeout=1) # あなたのコンピュータが *かなり* 遅くない限りは "100" を表示
295+ print pool.map(f, range(10)) # "[0, 1, 4,..., 81]" を表示
240296
241297
242-Reference
243----------
298+リファレンス
299+------------
244300
245-The :mod:`multiprocessing` package mostly replicates the API of the
246-:mod:`threading` module.
301+:mod:`multiprocessing` パッケージは :mod:`threading` モジュールの API とほとんど同じです。
247302
248-
249-:class:`Process` and exceptions
303+:class:`Process` クラスと例外
250304 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
251305
252306 .. class:: Process([group[, target[, name[, args[, kwargs]]]]])
253307
254- Process objects represent activity that is run in a separate process. The
255- :class:`Process` class has equivalents of all the methods of
256- :class:`threading.Thread`.
308+ Process オブジェクトは各プロセスの振る舞いを表します。
309+ :class:`Process` クラスは :class:`threading.Thread` クラスの全てのメソッドと同じインタフェースを提供します。
257310
258- The constructor should always be called with keyword arguments. *group*
259- should always be ``None``; it exists solely for compatibility with
260- :class:`threading.Thread`. *target* is the callable object to be invoked by
261- the :meth:`run()` method. It defaults to ``None``, meaning nothing is
262- called. *name* is the process name. By default, a unique name is constructed
263- of the form 'Process-N\ :sub:`1`:N\ :sub:`2`:...:N\ :sub:`k`' where N\
264- :sub:`1`,N\ :sub:`2`,...,N\ :sub:`k` is a sequence of integers whose length
265- is determined by the *generation* of the process. *args* is the argument
266- tuple for the target invocation. *kwargs* is a dictionary of keyword
267- arguments for the target invocation. By default, no arguments are passed to
268- *target*.
311+ コンストラクタは必ずキーワード引数で呼び出すべきです。
312+ 引数 *group* には必ず ``None`` を渡してください。
313+ この引数は :class:`threading.Thread` クラスとの互換性のためだけに残されています。
314+ 引数 *target* には、呼び出し可能オブジェクト (Collable Object) を渡します。
315+ このオブジェクトは :meth:`run()` メソッドから呼び出されます。
316+ この引数はデフォルトで ``None`` となっており、何も呼び出されません。
317+ 引数 *name* にはプロセス名を渡します。
318+ デフォルトでは、自動でユニークな名前が割り当てられます。
319+ 命名規則は、 'Process-N\ :sub:`1`:N\ :sub:`2`:...:N\ :sub:`k`' となります。
320+ ここで N\ :sub:`1`,N\ :sub:`2`,...,N\ :sub:`k` は整数の数列で、
321+ *作成した* プロセス数に対応します。
322+ 引数 *args* は target で指定された呼び出し可能オブジェクトへの引数を渡します。
323+ 同じく、引数 *kwargs* はキーワード引数を渡します。
324+ デフォルトでは、 *target* には引数が渡されないようになっています。
269325
270- If a subclass overrides the constructor, it must make sure it invokes the
271- base class constructor (:meth:`Process.__init__`) before doing anything else
272- to the process.
326+ サブクラスがコンストラクタをオーバーライドする場合は、
327+ そのプロセスに対する処理を行う前に基底クラスのコンストラクタ
328+ (:meth:`Process.__init__`) を実行しなければなりません。
273329
274330 .. method:: run()
275331
276- Method representing the process's activity.
332+ プロセスが実行する処理を表すメソッドです。
277333
278- You may override this method in a subclass. The standard :meth:`run`
279- method invokes the callable object passed to the object's constructor as
280- the target argument, if any, with sequential and keyword arguments taken
281- from the *args* and *kwargs* arguments, respectively.
334+ このメソッドはサブクラスでオーバーライドすることができます。
335+ 標準の :meth:`run` メソッドは呼び出し可能オブジェクトを呼び出します。
336+ この呼び出されるオブジェクトはコンストラクタの target 引数として渡されます。
337+ もしコンストラクタに *args* もしくは *kwargs* 引数が渡されていれば、
338+ 呼び出すオブジェクトにこれらの引数を渡します。
282339
283340 .. method:: start()
284341
285- Start the process's activity.
342+ プロセスの処理を開始するためのメソッドです。
286343
287- This must be called at most once per process object. It arranges for the
288- object's :meth:`run` method to be invoked in a separate process.
344+ このメソッドをプロセスごとに呼び出す必要があります。
345+ 各プロセスの :meth:`run` メソッドを呼び出す準備が完了します。
289346
290347 .. method:: join([timeout])
291348
292- Block the calling thread until the process whose :meth:`join` method is
293- called terminates or until the optional timeout occurs.
349+ :meth:`join` されたプロセスが terminate を呼び出すまで、もしくは
350+ オプションで指定したタイムアウトが発生するまで呼び出し側のスレッドを
351+ ブロックします。
294352
295- If *timeout* is ``None`` then there is no timeout.
353+ *timeout* が ``None`` ならタイムアウトは設定されません。
296354
297- A process can be joined many times.
355+ 1つのプロセスは何回も join することができます。
298356
299- A process cannot join itself because this would cause a deadlock. It is
300- an error to attempt to join a process before it has been started.
357+ プロセスは自分自身を join することはできません。それはデッドロックを引き起こすからです。
358+ プロセスが start される前に join しようとするとエラーが発生します。
301359
302360 .. attribute:: name
303361
304- The process's name.
362+ プロセス名です。
305363
306- The name is a string used for identification purposes only. It has no
307- semantics. Multiple processes may be given the same name. The initial
308- name is set by the constructor.
364+ この名前は文字列で、プロセスの識別にのみ使用されます。特別な命名規則はありません。
365+ 複数のプロセスが同じ名前を持つ場合もあります。
366+ また、この名前はコンストラクタにより初期化されます。
309367
310- .. method:: is_alive()
368+ .. method:: is_alive
311369
312- Return whether the process is alive.
370+ プロセスが実行中かを判別します。
313371
314- Roughly, a process object is alive from the moment the :meth:`start`
315- method returns until the child process terminates.
372+ おおまかに言って、プロセスオブジェクトは :meth:`start` メソッドを呼び出してから子プロセス終了までの期間が実行中となります。
316373
317374 .. attribute:: daemon
318375
319- The process's daemon flag, a Boolean value. This must be called before
320- :meth:`start` is called.
376+ デーモンプロセスであるかどうかのフラグであり、ブール値を設定します。
377+ この属性は :meth:`start` が呼び出される前に設定する必要があります。
321378
322- The initial value is inherited from the creating process.
379+ 初期値は作成するプロセスから継承します。
323380
324- When a process exits, it attempts to terminate all of its daemonic child
325- processes.
381+ プロセスが終了するとき、全てのデーモンの子プロセスを終了させようとします。
326382
327- Note that a daemonic process is not allowed to create child processes.
328- Otherwise a daemonic process would leave its children orphaned if it gets
329- terminated when its parent process exits.
383+ デーモンプロセスは子プロセスを作成できないことに注意してください。
384+ もしそうでなければ、そのデーモンの親プロセスが終了したときに子プロセスが孤児になってしまう場合があるからです。
330385
331- In addition to the :class:`Threading.Thread` API, :class:`Process` objects
332- also support the following attributes and methods:
386+ :class:`Threading.Thread` クラスのAPIに加えて :class:`Process` クラスのオブジェクトには
387+ 以下の属性およびメソッドがあります。
333388
334389 .. attribute:: pid
335390
336- Return the process ID. Before the process is spawned, this will be
337- ``None``.
391+ プロセスIDを返します。プロセスの生成前は ``None`` が設定されています。
338392
339393 .. attribute:: exitcode
340394
341- The child's exit code. This will be ``None`` if the process has not yet
342- terminated. A negative value *-N* indicates that the child was terminated
343- by signal *N*.
395+ 子プロセスの終了コードです。
396+ 子プロセスがまだ終了していない場合は ``None`` が返されます。
397+ 負の値 *-N* は子プロセスがシグナル *N* で終了したことを表します。
344398
345399 .. attribute:: authkey
346400
347- The process's authentication key (a byte string).
401+ プロセスの認証キーです (バイト文字列です)。
348402
349- When :mod:`multiprocessing` is initialized the main process is assigned a
350- random string using :func:`os.random`.
403+ :mod:`multiprocessing` モジュールがメインプロセスにより初期化される場合には、
404+ :func:`os.random` 関数を使用してランダムな値が設定されます。
351405
352- When a :class:`Process` object is created, it will inherit the
353- authentication key of its parent process, although this may be changed by
354- setting :attr:`authkey` to another byte string.
406+ :class:`Process` クラスのオブジェクトの作成時にその親プロセスから認証キーを継承します。
407+ もしくは :attr:`authkey` に別のバイト文字列を設定することもできます。
355408
356- See :ref:`multiprocessing-auth-keys`.
409+ 詳細は :ref:`multiprocessing-auth-keys` を参照してください。
357410
358411 .. method:: terminate()
359412
360- Terminate the process. On Unix this is done using the ``SIGTERM`` signal;
361- on Windows :cfunc:`TerminateProcess` is used. Note that exit handlers and
362- finally clauses, etc., will not be executed.
413+ プロセスを終了します。Unix 環境では ``SIGTERM`` シグナルを、
414+ Windows 環境では :cfunc:`TerminateProcess` を使用して終了させます。
415+ 終了ハンドラや finally 節などは、実行されないことに注意してください。
363416
364- Note that descendant processes of the process will *not* be terminated --
365- they will simply become orphaned.
417+ このメソッドにより終了するプロセスの子孫プロセスは、終了 *しません* 。
418+ そういった子孫プロセスは単純に孤児になります。
366419
367420 .. warning::
368421
369- If this method is used when the associated process is using a pipe or
370- queue then the pipe or queue is liable to become corrupted and may
371- become unusable by other process. Similarly, if the process has
372- acquired a lock or semaphore etc. then terminating it is liable to
373- cause other processes to deadlock.
422+ このメソッドの使用時に、関連付けられたプロセスがパイプやキューを使用している場合には、
423+ 使用中のパイプやキューが破損して他のプロセスから使用できなくなる可能性があります。
424+ 同様に、プロセスがロックやセマフォなどを取得している場合には、
425+ このプロセスが終了してしまうと
426+ 他のプロセスのデッドロックの原因になるでしょう。
374427
375- Note that the :meth:`start`, :meth:`join`, :meth:`is_alive` and
376- :attr:`exit_code` methods should only be called by the process that created
377- the process object.
428+ プロセスオブジェクトが作成したプロセスのみが :meth:`start`, :meth:`join`,
429+ :meth:`is_alive` と :attr:`exit_code` のメソッドを呼び出すべきです。
378430
379- Example usage of some of the methods of :class:`Process`::
431+ 以下の例では :class:`Process` のメソッドの使い方を示しています。 ::
380432
381- >>> import processing, time, signal
382- >>> p = processing.Process(target=time.sleep, args=(1000,))
433+ >>> import multiprocessing, time, signal
434+ >>> p = multiprocessing.Process(target=time.sleep, args=(1000,))
383435 >>> print p, p.is_alive()
384436 <Process(Process-1, initial)> False
385437 >>> p.start()
@@ -394,229 +446,216 @@
394446
395447 .. exception:: BufferTooShort
396448
397- Exception raised by :meth:`Connection.recv_bytes_into()` when the supplied
398- buffer object is too small for the message read.
449+ この例外は :meth:`Connection.recv_bytes_into()` によって発生し、
450+ バッファオブジェクトが小さすぎてメッセージが読み込めないことを示します。
399451
400- If ``e`` is an instance of :exc:`BufferTooShort` then ``e.args[0]`` will give
401- the message as a byte string.
452+ ``e`` が :exc:`BufferTooShort` のインスタンスとすると、
453+ ``e.args[0]`` はバイト文字列でそのメッセージを取得できます。
402454
403455
404-Pipes and Queues
405-~~~~~~~~~~~~~~~~
456+パイプ (Pipe) とキュー (Queue)
457+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
406458
407-When using multiple processes, one generally uses message passing for
408-communication between processes and avoids having to use any synchronization
409-primitives like locks.
459+マルチプロセス環境では、
460+一般的にメッセージパッシングをプロセス間通信のために使用し、
461+ロックのような同期プリミティブの使用しないようにします。
410462
411-For passing messages one can use :func:`Pipe` (for a connection between two
412-processes) or a queue (which allows multiple producers and consumers).
463+メッセージのやりとりのために :func:`Pipe` (2つのプロセス間の通信用)、
464+もしくはキュー (複数プロセスがメッセージを生成、消費する通信用) を使用することができます。
413465
414-The :class:`Queue` and :class:`JoinableQueue` types are multi-producer,
415-multi-consumer FIFO queues modelled on the :class:`Queue.Queue` class in the
416-standard library. They differ in that :class:`Queue` lacks the
417-:meth:`~Queue.Queue.task_done` and :meth:`~Queue.Queue.join` methods introduced
418-into Python 2.5's :class:`Queue.Queue` class.
466+:class:`Queue` と :class:`JoinableQueue` は複数プロセスから生成/消費を行う FIFO キューです。
467+これらのキューは標準ライブラリの :class:`Queue.Queue` を模倣しています。
468+:class:`Queue` には Python 2.5 の :class:`Queue.Queue` クラスで導入された
469+:meth:`~Queue.Queue.task_done` と :meth:`~Queue.Queue.join` メソッドがないことが違う点です。
419470
420-If you use :class:`JoinableQueue` then you **must** call
421-:meth:`JoinableQueue.task_done` for each task removed from the queue or else the
422-semaphore used to count the number of unfinished tasks may eventually overflow
423-raising an exception.
471+もし :class:`JoinableQueue` を使用するなら、キューから削除される各タスクのために
472+:meth:`JoinableQueue.task_done` を呼び出さなければ **なりません** 。
473+もしくは、ある例外を発生させてオーバーフローする可能性がある未終了タスクを
474+数えるためにセマフォが使用されます。
424475
425-Note that one can also create a shared queue by using a manager object -- see
426-:ref:`multiprocessing-managers`.
476+管理オブジェクトを使用することで共有キューを作成できることも覚えておいてください。
477+詳細は :ref:`multiprocessing-managers` を参照してください。
427478
428479 .. note::
429480
430- :mod:`multiprocessing` uses the usual :exc:`Queue.Empty` and
431- :exc:`Queue.Full` exceptions to signal a timeout. They are not available in
432- the :mod:`multiprocessing` namespace so you need to import them from
433- :mod:`Queue`.
481+ :mod:`multiprocessing` は通常の :exc:`Queue.Empty` と、
482+ タイムアウトのシグナルを送るために :exc:`Queue.Full` 例外を使用します。
483+ それらは :mod:`Queue` からインポートする必要があるので :mod:`multiprocessing` の名前空間では利用できません。
434484
435-
436485 .. warning::
437486
438- If a process is killed using :meth:`Process.terminate` or :func:`os.kill`
439- while it is trying to use a :class:`Queue`, then the data in the queue is
440- likely to become corrupted. This may cause any other processes to get an
441- exception when it tries to use the queue later on.
487+ :class:`Queue` を利用しようとしている最中にプロセスを
488+ :meth:`Process.terminate` や :func:`os.kill` で終了させる場合、
489+ キューにあるデータは破損し易くなります。
490+ 終了した後で他のプロセスがキューを利用しようとすると、例外を発生させる可能性があります。
442491
443492 .. warning::
444493
445- As mentioned above, if a child process has put items on a queue (and it has
446- not used :meth:`JoinableQueue.cancel_join_thread`), then that process will
447- not terminate until all buffered items have been flushed to the pipe.
494+ 上述したように、もし子プロセスがキューへ要素を追加するなら
495+ (そして :meth:`JoinableQueue.cancel_join_thread` を使用しない)
496+ そのプロセスはバッファされた全ての要素がパイプへフラッシュされるまで終了しません。
448497
449- This means that if you try joining that process you may get a deadlock unless
450- you are sure that all items which have been put on the queue have been
451- consumed. Similarly, if the child process is non-daemonic then the parent
452- process may hang on exit when it tries to join all its non-daemonic children.
498+ これは、そのプロセスを join しようとする場合、
499+ キューに追加された全ての要素が消費されるのを確認しない限り、
500+ デッドロックを発生させる可能性があることを意味します。
501+ 似たような現象で、子プロセスが非デーモンプロセスの場合、
502+ 親プロセスは終了時に非デーモンの全ての子プロセスを join しようとして
503+ ハングアップする可能性があります。
453504
454- Note that a queue created using a manager does not have this issue. See
455- :ref:`multiprocessing-programming`.
505+ Manager を使用して作成されたキューではこの問題はありません。
506+ 詳細は :ref:`multiprocessing-programming` を参照してください。
456507
457-For an example of the usage of queues for interprocess communication see
458-:ref:`multiprocessing-examples`.
508+プロセス間通信におけるキューの使用方法は :ref:`multiprocessing-examples` を参照してください。
459509
460-
461510 .. function:: Pipe([duplex])
462511
463- Returns a pair ``(conn1, conn2)`` of :class:`Connection` objects representing
464- the ends of a pipe.
512+ パイプの終端を表す :class:`Connection` オブジェクトのタプル ``(conn1, conn2)`` を返します。
465513
466- If *duplex* is ``True`` (the default) then the pipe is bidirectional. If
467- *duplex* is ``False`` then the pipe is unidirectional: ``conn1`` can only be
468- used for receiving messages and ``conn2`` can only be used for sending
469- messages.
514+ *duplex* が ``True`` (デフォルト) なら、双方向性パイプです。
515+ *duplex* が ``False`` なら、パイプは一方向性です。
516+ ``conn1`` はメッセージの受信専用に ``conn2`` はメッセージの送信専用として使用されます。
470517
471-
472518 .. class:: Queue([maxsize])
473519
474- Returns a process shared queue implemented using a pipe and a few
475- locks/semaphores. When a process first puts an item on the queue a feeder
476- thread is started which transfers objects from a buffer into the pipe.
520+ パイプや2~3個のロック/セマフォを使用して実装されたプロセス共有キューを返します。
521+ あるプロセスが最初に要素をキューへ追加するとき、
522+ バッファからパイプの中へオブジェクトを転送する供給スレッドが開始されます。
477523
478- The usual :exc:`Queue.Empty` and :exc:`Queue.Full` exceptions from the
479- standard library's :mod:`Queue` module are raised to signal timeouts.
524+ 標準ライブラリの :mod:`Queue` モジュールからの通常の :exc:`Queue.Empty` や
525+ :exc:`Queue.Full` 例外はタイムアウトのシグナルを送るために発生します。
480526
481- :class:`Queue` implements all the methods of :class:`Queue.Queue` except for
482- :meth:`~Queue.Queue.task_done` and :meth:`~Queue.Queue.join`.
527+ :class:`Queue` は :meth:`~Queue.Queue.task_done` や :meth:`~Queue.Queue.join` を除く
528+ :class:`Queue.Queue` の全てのメソッドを実装します。
483529
484530 .. method:: qsize()
485531
486- Return the approximate size of the queue. Because of
487- multithreading/multiprocessing semantics, this number is not reliable.
532+ おおよそのキューのサイズを返します。
533+ マルチスレッディング/マルチプロセスの特性上、この数値は信用できません。
488534
489- Note that this may raise :exc:`NotImplementedError` on Unix platforms like
490- Mac OS X where ``sem_getvalue()`` is not implemented.
535+ これは ``sem_getvalue()`` が実装されていない Mac OS X のような Unix プラットホーム上で
536+ :exc:`NotImplementedError` を発生させる可能性があることを覚えておいてください。
491537
492538 .. method:: empty()
493539
494- Return ``True`` if the queue is empty, ``False`` otherwise. Because of
495- multithreading/multiprocessing semantics, this is not reliable.
540+ キューが空っぽなら ``True`` を、そうでなければ ``False`` を返します。
541+ マルチスレッディング/マルチプロセスの特性上、これは信用できません。
496542
497543 .. method:: full()
498544
499- Return ``True`` if the queue is full, ``False`` otherwise. Because of
500- multithreading/multiprocessing semantics, this is not reliable.
545+ キューがいっぱいなら ``True`` を、そうでなければ ``False`` を返します。
546+ マルチスレッディング/マルチプロセスの特性上、これは信用できません。
501547
502548 .. method:: put(item[, block[, timeout]])
503549
504- Put item into the queue. If the optional argument *block* is ``True``
505- (the default) and *timeout* is ``None`` (the default), block if necessary until
506- a free slot is available. If *timeout* is a positive number, it blocks at
507- most *timeout* seconds and raises the :exc:`Queue.Full` exception if no
508- free slot was available within that time. Otherwise (*block* is
509- ``False``), put an item on the queue if a free slot is immediately
510- available, else raise the :exc:`Queue.Full` exception (*timeout* is
511- ignored in that case).
550+ キューの中へ要素を追加します。オプションの引数 *block* が ``True`` (デフォルト) 且つ
551+ *timeout* が ``None`` (デフォルト) なら、空きスロットが利用可能になるまで必要であればブロックします。
552+ *timeout* が正の数なら、最大 *timeout* 秒ブロックして、
553+ その時間内に空きスロットが利用できなかったら :exc:`Queue.Full` 例外を発生させます。
554+ それ以外 ( *block* が ``False`` ) で、
555+ 空きスロットがすぐに利用可能な場合はキューに要素を追加します。
556+ そうでなければ :exc:`Queue.Full` 例外が発生します(その場合 *timeout* は無視されます)。
512557
513558 .. method:: put_nowait(item)
514559
515- Equivalent to ``put(item, False)``.
560+ ``put(item, False)`` と等価です。
516561
517562 .. method:: get([block[, timeout]])
518563
519- Remove and return an item from the queue. If optional args *block* is
520- ``True`` (the default) and *timeout* is ``None`` (the default), block if
521- necessary until an item is available. If *timeout* is a positive number,
522- it blocks at most *timeout* seconds and raises the :exc:`Queue.Empty`
523- exception if no item was available within that time. Otherwise (block is
524- ``False``), return an item if one is immediately available, else raise the
525- :exc:`Queue.Empty` exception (*timeout* is ignored in that case).
564+ キューから要素を取り出して削除します。オプションの引数 *block* が ``True`` (デフォルト) 且つ
565+ *timeout* が ``None`` (デフォルト) なら、要素が取り出せるまで必要であればブロックします。
566+ *timeout* が正の数なら、最大 *timeout* 秒ブロックして、
567+ その時間内に要素が取り出せなかったら :exc:`Queue.Empty` 例外を発生させます。
568+ それ以外 ( *block* が ``False`` ) で、
569+ 要素がすぐに取り出せる場合は要素を返します。
570+ そうでなければ :exc:`Queue.Empty` 例外が発生します(その場合 *timeout* は無視されます)。
526571
527572 .. method:: get_nowait()
528573 get_no_wait()
529574
530- Equivalent to ``get(False)``.
575+ ``get(False)`` と等価です。
531576
532- :class:`multiprocessing.Queue` has a few additional methods not found in
533- :class:`Queue.Queue`. These methods are usually unnecessary for most
534- code:
577+ :class:`multiprocessing.Queue` は :class:`Queue.Queue` にはない追加メソッドがあります。
578+ これらのメソッドは通常、ほとんどのコードに必要ありません。
535579
536580 .. method:: close()
537581
538- Indicate that no more data will be put on this queue by the current
539- process. The background thread will quit once it has flushed all buffered
540- data to the pipe. This is called automatically when the queue is garbage
541- collected.
582+ カレントプロセスからこのキューへそれ以上データが追加されないことを表します。
583+ バックグラウンドスレッドはパイプへバッファされた全てのデータをフラッシュするとすぐに終了します。
584+ これはキューがガベージコレクトされるときに自動的に呼び出されます。
542585
543586 .. method:: join_thread()
544587
545- Join the background thread. This can only be used after :meth:`close` has
546- been called. It blocks until the background thread exits, ensuring that
547- all data in the buffer has been flushed to the pipe.
588+ バックグラウンドスレッドを join します。
589+ このメソッドは :meth:`close` が呼び出された後でのみ使用されます。
590+ バッファされた全てのデータがパイプへフラッシュされるのを保証した上で、
591+ バックグラウンドスレッドが終了するまでブロックします。
548592
549- By default if a process is not the creator of the queue then on exit it
550- will attempt to join the queue's background thread. The process can call
551- :meth:`cancel_join_thread` to make :meth:`join_thread` do nothing.
593+ デフォルトでは、あるプロセスがキューを作成していない場合、
594+ 終了時にキューのバックグラウンドスレッドを join しようとします。
595+ そのプロセスは :meth:`join_thread` が何もしないように :meth:`cancel_join_thread` を呼び出すことができます。
552596
553597 .. method:: cancel_join_thread()
554598
555- Prevent :meth:`join_thread` from blocking. In particular, this prevents
556- the background thread from being joined automatically when the process
557- exits -- see :meth:`join_thread`.
599+ :meth:`join_thread` がブロッキングするのを防ぎます。
600+ 特にこれはバックグラウンドスレッドがそのプロセスの終了時に
601+ 自動的に join されるのを防ぎます。
602+ 詳細は :meth:`join_thread` を参照してください。
558603
559-
560604 .. class:: JoinableQueue([maxsize])
561605
562- :class:`JoinableQueue`, a :class:`Queue` subclass, is a queue which
563- additionally has :meth:`task_done` and :meth:`join` methods.
606+ :class:`JoinableQueue` は :class:`Queue` のサブクラスであり、
607+ :meth:`task_done` や :meth:`join` メソッドが追加されているキューです。
564608
565609 .. method:: task_done()
566610
567- Indicate that a formerly enqueued task is complete. Used by queue consumer
568- threads. For each :meth:`~Queue.get` used to fetch a task, a subsequent
569- call to :meth:`task_done` tells the queue that the processing on the task
570- is complete.
611+ 以前にキューへ追加されたタスクが完了したことを表します。キュー消費スレッドによって使用されます。
612+ タスクをフェッチするために使用されるそれぞれの :meth:`~Queue.get` では、
613+ 次に :meth:`task_done` を呼び出してタスクの処理が完了したことをキューへ伝えます。
571614
572- If a :meth:`~Queue.join` is currently blocking, it will resume when all
573- items have been processed (meaning that a :meth:`task_done` call was
574- received for every item that had been :meth:`~Queue.put` into the queue).
615+ もし :meth:`~Queue.join` がブロッキング状態なら、
616+ 全ての要素が処理されたときに復帰します( :meth:`task_done` 呼び出しが
617+ 全ての要素からキュー内へ :meth:`~Queue.put` されたと受け取ったことを意味します)。
575618
576- Raises a :exc:`ValueError` if called more times than there were items
577- placed in the queue.
619+ キューにある要素より多く呼び出された場合 :exc:`ValueError` が発生します。
578620
579-
580621 .. method:: join()
581622
582- Block until all items in the queue have been gotten and processed.
623+ キューにある全ての要素が取り出されて処理されるまでブロッキングします。
583624
584- The count of unfinished tasks goes up whenever an item is added to the
585- queue. The count goes down whenever a consumer thread calls
586- :meth:`task_done` to indicate that the item was retrieved and all work on
587- it is complete. When the count of unfinished tasks drops to zero,
588- :meth:`~Queue.join` unblocks.
625+ キューに要素が追加されると未終了タスク数が増えます。
626+ キューの要素が取り出されて全て処理が完了したことを表す
627+ :meth:`task_done` を消費スレッドが呼び出すと数が減ります。
628+ 未終了タスク数がゼロになると :meth:`~Queue.join` はブロッキングを解除します。
589629
590-
591-Miscellaneous
630+その他の関数(Miscellaneous)
592631 ~~~~~~~~~~~~~
593632
594633 .. function:: active_children()
595634
596- Return list of all live children of the current process.
635+ カレントプロセスのアクティブな子プロセスの全てのリストを返します。
597636
598- Calling this has the side affect of "joining" any processes which have
599- already finished.
637+ これを呼び出すと "join" して既に終了しているプロセスには副作用があります。
600638
601639 .. function:: cpu_count()
602640
603- Return the number of CPUs in the system. May raise
604- :exc:`NotImplementedError`.
641+ システムの CPU 数を返します。
642+ もしかしたら :exc:`NotImplementedError` が発生するかもしれません。
605643
606644 .. function:: current_process()
607645
608- Return the :class:`Process` object corresponding to the current process.
646+ カレントプロセスに対応する :class:`Process` オブジェクトを返します。
609647
610- An analogue of :func:`threading.current_thread`.
648+ :func:`threading.current_thread` とよく似た関数です。
611649
612650 .. function:: freeze_support()
613651
614- Add support for when a program which uses :mod:`multiprocessing` has been
615- frozen to produce a Windows executable. (Has been tested with **py2exe**,
616- **PyInstaller** and **cx_Freeze**.)
652+ :mod:`multiprocessing` を使用するプログラムが固まったときに
653+ ウィンドウを実行状態にすることをサポートします。
654+ ( **py2exe** , **PyInstaller** や **cx_Freeze** でテストされています。)
617655
618- One needs to call this function straight after the ``if __name__ ==
619- '__main__'`` line of the main module. For example::
656+ メインモジュールの ``if __name__ == '__main__'`` の後で
657+ この関数を連続的に呼び出す必要があります。
658+ 以下に例を示します。 ::
620659
621660 from multiprocessing import Process, freeze_support
622661
@@ -627,110 +666,99 @@
627666 freeze_support()
628667 Process(target=f).start()
629668
630- If the ``freeze_support()`` line is missed out then trying to run the frozen
631- executable will raise :exc:`RuntimeError`.
669+ もし ``freeze_support()`` の行がない場合、固まった実行状態で
670+ 実行しようとして :exc:`RuntimeError` を発生させます。
632671
633- If the module is being run normally by the Python interpreter then
634- :func:`freeze_support` has no effect.
672+ そのモジュールが Python インタプリタによって普通に実行されるなら
673+ :func:`freeze_support` は何の影響もありません。
635674
636675 .. function:: set_executable()
637676
638- Sets the path of the python interpreter to use when starting a child process.
639- (By default :data:`sys.executable` is used). Embedders will probably need to
640- do some thing like ::
677+ 子プロセスを開始するときに使用する Python インタプリタのパスを設定します。
678+ (デフォルトでは :data:`sys.executable` が使用されます)。
679+ コードに組み込むときは、おそらく次のようにする必要があります。
680+ ::
641681
642682 setExecutable(os.path.join(sys.exec_prefix, 'pythonw.exe'))
643683
644- before they can create child processes. (Windows only)
684+ 子プロセスを生成する前に行います。 (Windows 専用)
645685
646-
647686 .. note::
648687
649- :mod:`multiprocessing` contains no analogues of
688+ :mod:`multiprocessing` には
650689 :func:`threading.active_count`, :func:`threading.enumerate`,
651690 :func:`threading.settrace`, :func:`threading.setprofile`,
652- :class:`threading.Timer`, or :class:`threading.local`.
691+ :class:`threading.Timer` や :class:`threading.local` のような関数はありません。
653692
654-
655693 Connection Objects
656694 ~~~~~~~~~~~~~~~~~~
657695
658-Connection objects allow the sending and receiving of picklable objects or
659-strings. They can be thought of as message oriented connected sockets.
696+Connection オブジェクトは pickle でシリアライズ可能なオブジェクトか文字列を送ったり、受け取ったりします。
697+そういったオブジェクトはメッセージ指向の接続ソケットと考えられます。
660698
661-Connection objects usually created using :func:`Pipe` -- see also
662-:ref:`multiprocessing-listeners-clients`.
699+Connection オブジェクトは通常は :func:`Pipe` を使用して作成されます。
700+詳細は :ref:`multiprocessing-listeners-clients` も参照してください。
663701
664702 .. class:: Connection
665703
666704 .. method:: send(obj)
667705
668- Send an object to the other end of the connection which should be read
669- using :meth:`recv`.
706+ コネクションの向こう側へ :meth:`recv` を使用して読み込むオブジェクトを送ります。
670707
671- The object must be picklable.
708+ オブジェクトは pickle でシリアライズ可能でなければなりません。
672709
673710 .. method:: recv()
674711
675- Return an object sent from the other end of the connection using
676- :meth:`send`. Raises :exc:`EOFError` if there is nothing left to receive
677- and the other end was closed.
712+ コネクションの向こう側から :meth:`send` を使用して送られたオブジェクトを返します。
713+ 何も受け取らずにコネクションの向こう側でクローズされた場合 :exc:`EOFError` が発生します。
678714
679715 .. method:: fileno()
680716
681- Returns the file descriptor or handle used by the connection.
717+ コネクションが使用するハンドラか、ファイルディスクリプタを返します。
682718
683719 .. method:: close()
684720
685- Close the connection.
721+ コネクションをクローズします。
686722
687- This is called automatically when the connection is garbage collected.
723+ コネクションがガベージコレクトされるときに自動的に呼び出されます。
688724
689725 .. method:: poll([timeout])
690726
691- Return whether there is any data available to be read.
727+ 読み込み可能なデータがあるかどうかを返します。
692728
693- If *timeout* is not specified then it will return immediately. If
694- *timeout* is a number then this specifies the maximum time in seconds to
695- block. If *timeout* is ``None`` then an infinite timeout is used.
729+ *timeout* が指定されていなければすぐに返します。
730+ *timeout* に数値を指定すると、最大指定した秒数をブロッキングします。
731+ *timeout* に ``None`` を指定するとタイムアウトせずにずっとブロッキングします。
696732
697733 .. method:: send_bytes(buffer[, offset[, size]])
698734
699- Send byte data from an object supporting the buffer interface as a
700- complete message.
735+ バッファインタフェースをサポートするオブジェクトから完全なメッセージとしてバイトデータを送ります。
701736
702- If *offset* is given then data is read from that position in *buffer*. If
703- *size* is given then that many bytes will be read from buffer.
737+ *offset* が指定されると *buffer* のその位置からデータが読み込まれます。
738+ *size* が指定されると大量データがバッファから読み込まれます。
704739
705740 .. method:: recv_bytes([maxlength])
706741
707- Return a complete message of byte data sent from the other end of the
708- connection as a string. Raises :exc:`EOFError` if there is nothing left
709- to receive and the other end has closed.
742+ 文字列のようにコネクションの向こう側から送られたバイトデータの完全なメッセージを返します。
743+ 何も受け取らずにコネクションの向こう側でクローズされた場合 :exc:`EOFError` が発生します。
710744
711- If *maxlength* is specified and the message is longer than *maxlength*
712- then :exc:`IOError` is raised and the connection will no longer be
713- readable.
745+ *maxlength* を指定して、且つ *maxlength* よりメッセージが長い場合、
746+ :exc:`IOError` を発生させて、それ以上はコネクションから読み込めなくなります。
714747
715748 .. method:: recv_bytes_into(buffer[, offset])
716749
717- Read into *buffer* a complete message of byte data sent from the other end
718- of the connection and return the number of bytes in the message. Raises
719- :exc:`EOFError` if there is nothing left to receive and the other end was
720- closed.
750+ コネクションの向こう側から送られたバイトデータを *buffer* に読み込み、メッセージのバイト数を返します。
751+ 何も受け取らずにコネクションの向こう側でクローズされた場合 :exc:`EOFError` が発生します。
721752
722- *buffer* must be an object satisfying the writable buffer interface. If
723- *offset* is given then the message will be written into the buffer from
724- *that position. Offset must be a non-negative integer less than the
725- *length of *buffer* (in bytes).
753+ *buffer* は書き込み可能なバッファインタフェースを備えたオブジェクトでなければなりません。
754+ *offset* が与えられたら、その位置からバッファへメッセージが書き込まれます。
755+ オフセットは *buffer* バイトよりも小さい正の数でなければなりません。
726756
727- If the buffer is too short then a :exc:`BufferTooShort` exception is
728- raised and the complete message is available as ``e.args[0]`` where ``e``
729- is the exception instance.
757+ バッファがあまりに小さいと :exc:`BufferTooShort` 例外が発生します。
758+ ``e`` が例外インスタンスとすると完全なメッセージは ``e.args[0]`` で確認できます。
730759
760+例:
731761
732-For example:
733-
734762 >>> from multiprocessing import Pipe
735763 >>> a, b = Pipe()
736764 >>> a.send([1, 'hello', None])
@@ -751,248 +779,243 @@
751779
752780 .. warning::
753781
754- The :meth:`Connection.recv` method automatically unpickles the data it
755- receives, which can be a security risk unless you can trust the process
756- which sent the message.
782+ :meth:`Connection.recv` メソッドは受信したデータを自動的に unpickle 化します。
783+ それはメッセージを送ったプロセスが信頼できる場合を除いてセキュリティリスクになります。
757784
758- Therefore, unless the connection object was produced using :func:`Pipe` you
759- should only use the :meth:`~Connection.recv` and :meth:`~Connection.send`
760- methods after performing some sort of authentication. See
761- :ref:`multiprocessing-auth-keys`.
785+ そのため :func:`Pipe` を使用してコネクションオブジェクトを生成する場合を除いて、
786+ 何らかの認証処理を実行した後で :meth:`~Connection.recv` や
787+ :meth:`~Connection.send` メソッドのみを使用すべきです。
788+ 詳細は :ref:`multiprocessing-auth-keys` を参照してください。
762789
763790 .. warning::
764791
765- If a process is killed while it is trying to read or write to a pipe then
766- the data in the pipe is likely to become corrupted, because it may become
767- impossible to be sure where the message boundaries lie.
792+ もしプロセスがパイプの読み込み又は書き込み中に kill されると、
793+ メッセージの境界が正しいかどうか分からないので、
794+ そのパイプのデータは破壊されたようになります。
768795
769796
770-Synchronization primitives
771-~~~~~~~~~~~~~~~~~~~~~~~~~~
797+同期プリミティブ
798+~~~~~~~~~~~~~~~~
772799
773-Generally synchronization primitives are not as necessary in a multiprocess
774-program as they are in a multithreaded program. See the documentation for
775-:mod:`threading` module.
776800
777-Note that one can also create synchronization primitives by using a manager
778-object -- see :ref:`multiprocessing-managers`.
801+一般的に同期プリミティブはマルチスレッドプログラムのようにマルチプロセスプログラムでは必要ありません。
802+詳細は :mod:`threading` モジュールのドキュメントを参照してください。
779803
804+マネージャオブジェクトを使用して同期プリミティブを作成できることも覚えておいてください。
805+詳細は :ref:`multiprocessing-managers` を参照してください。
806+
780807 .. class:: BoundedSemaphore([value])
781808
782- A bounded semaphore object: a clone of :class:`threading.BoundedSemaphore`.
809+ 束縛されたセマフォオブジェクト: :class:`threading.BoundedSemaphore` のクローンです。
783810
784- (On Mac OS X this is indistinguishable from :class:`Semaphore` because
785- ``sem_getvalue()`` is not implemented on that platform).
811+ (Mac OS X では ``sem_getvalue()`` が実装されていないので :class:`Semaphore` と区別がつきません。)
786812
787813 .. class:: Condition([lock])
788814
789- A condition variable: a clone of :class:`threading.Condition`.
815+ 状態変数: :class:`threading.Condition` のクローンです。
790816
791- If *lock* is specified then it should be a :class:`Lock` or :class:`RLock`
792- object from :mod:`multiprocessing`.
817+ *lock* を指定するなら :mod:`multiprocessing` の :class:`Lock` か :class:`RLock` オブジェクトにすべきです。
793818
794819 .. class:: Event()
795820
796- A clone of :class:`threading.Event`.
821+ :class:`threading.Event` のクローンです。
797822
798823 .. class:: Lock()
799824
800- A non-recursive lock object: a clone of :class:`threading.Lock`.
825+ 非再帰的なロックオブジェクト: :class:`threading.Lock` のクローンです。
801826
802827 .. class:: RLock()
803828
804- A recursive lock object: a clone of :class:`threading.RLock`.
829+ 再帰的なロックオブジェクト: :class:`threading.RLock` のクローンです。
805830
806831 .. class:: Semaphore([value])
807832
808- A bounded semaphore object: a clone of :class:`threading.Semaphore`.
833+ 束縛されたセマフォオブジェクト: :class:`threading.Semaphore` のクローンです。
809834
810835 .. note::
811836
812- The :meth:`acquire` method of :class:`BoundedSemaphore`, :class:`Lock`,
813- :class:`RLock` and :class:`Semaphore` has a timeout parameter not supported
814- by the equivalents in :mod:`threading`. The signature is
815- ``acquire(block=True, timeout=None)`` with keyword parameters being
816- acceptable. If *block* is ``True`` and *timeout* is not ``None`` then it
817- specifies a timeout in seconds. If *block* is ``False`` then *timeout* is
818- ignored.
837+ :class:`BoundedSemaphore`, :class:`Lock`, :class:`RLock` と :class:`Semaphore`
838+ の :meth:`acquire` メソッドは :mod:`threading` ではサポートされていない
839+ タイムアウトパラメータを取ります。その引数はキーワード引数で受け取れる
840+ ``acquire(block=True, timeout=None)`` です。
841+ *block* が ``True`` 且つ *timeout* が ``None`` ではないなら、
842+ タイムアウトが秒単位で設定されます。
843+ *block* が ``False`` なら *timeout* は無視されます。
844+
845+ Mac OS X では ``sem_timedwait`` がサポートされていないので、
846+ タイムアウトの引数は無視されることに注意してください。
819847
820848 .. note::
821849
822- If the SIGINT signal generated by Ctrl-C arrives while the main thread is
823- blocked by a call to :meth:`BoundedSemaphore.acquire`, :meth:`Lock.acquire`,
850+ メインスレッドが :meth:`BoundedSemaphore.acquire`, :meth:`Lock.acquire`,
824851 :meth:`RLock.acquire`, :meth:`Semaphore.acquire`, :meth:`Condition.acquire`
825- or :meth:`Condition.wait` then the call will be immediately interrupted and
826- :exc:`KeyboardInterrupt` will be raised.
852+ 又は :meth:`Condition.wait` を呼び出してブロッキング状態のときに Ctrl-C で
853+ 生成される SIGINT シグナルを受け取ると、その呼び出しはすぐに中断されて
854+ :exc:`KeyboardInterrupt` が発生します。
827855
828- This differs from the behaviour of :mod:`threading` where SIGINT will be
829- ignored while the equivalent blocking calls are in progress.
856+ これは同等のブロッキング呼び出しが実行中のときに SIGINT が無視される
857+ :mod:`threading` の振る舞いとは違っています。
830858
859+..
860+ Shared :mod:`ctypes` Objects
861+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
831862
832-Shared :mod:`ctypes` Objects
833-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
863+共有 :mod:`ctypes` オブジェクト
864+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
834865
835-It is possible to create shared objects using shared memory which can be
836-inherited by child processes.
866+子プロセスにより継承される共有メモリを使用する共有オブジェクトを作成することができます。
837867
838-.. function:: Value(typecode_or_type[, *args, lock]])
868+.. function:: Value(typecode_or_type, *args[, lock])
839869
840- Return a :mod:`ctypes` object allocated from shared memory. By default the
841- return value is actually a synchronized wrapper for the object.
870+ 共有メモリから割り当てられた :mod:`ctypes` オブジェクトを返します。
871+ デフォルトでは、返り値は実際のオブジェクトの同期ラッパーです。
842872
843- *typecode_or_type* determines the type of the returned object: it is either a
844- ctypes type or a one character typecode of the kind used by the :mod:`array`
845- module. *\*args* is passed on to the constructor for the type.
873+ *typecode_or_type* は返されるオブジェクトの型を決めます。
874+ それは ctypes の型か :mod:`array` モジュールで使用されるような1文字の型コードかのどちらか一方です。
875+ *\*args* は型のコンストラクタへ渡されます。
846876
847- If *lock* is ``True`` (the default) then a new lock object is created to
848- synchronize access to the value. If *lock* is a :class:`Lock` or
849- :class:`RLock` object then that will be used to synchronize access to the
850- value. If *lock* is ``False`` then access to the returned object will not be
851- automatically protected by a lock, so it will not necessarily be
852- "process-safe".
877+ *lock* が ``True`` (デフォルト) なら、値へ同期アクセスするために新たな
878+ ロックオブジェクトが作成されます。 *lock* が :class:`Lock` か :class:`RLock`
879+ なら値への同期アクセスに使用されます。 *lock* が ``False`` なら、返された
880+ オブジェクトへのアクセスはロックにより自動的に保護されません。
881+ そのため、必ずしも "プロセスセーフ" ではありません。
853882
854- Note that *lock* is a keyword-only argument.
883+ *lock* はキーワード引数でのみ指定することに注意してください。
855884
856885 .. function:: Array(typecode_or_type, size_or_initializer, *, lock=True)
857886
858- Return a ctypes array allocated from shared memory. By default the return
859- value is actually a synchronized wrapper for the array.
887+ 共有メモリから割り当てられた ctypes 配列を返します。
888+ デフォルトでは、返り値は実際の配列の同期ラッパーです。
860889
861- *typecode_or_type* determines the type of the elements of the returned array:
862- it is either a ctypes type or a one character typecode of the kind used by
863- the :mod:`array` module. If *size_or_initializer* is an integer, then it
864- determines the length of the array, and the array will be initially zeroed.
865- Otherwise, *size_or_initializer* is a sequence which is used to initialize
866- the array and whose length determines the length of the array.
890+ *typecode_or_type* は返される配列の要素の型を決めます。
891+ それは ctypes の型か :mod:`array` モジュールで使用されるような1文字の型コードかのどちらか一方です。
892+ *size_or_initializer* が整数なら、配列の長さを決定し、その配列はゼロで初期化されます。
893+ 別の使用方法として *size_or_initializer* は配列の初期化に使用されるシーケンスになり、
894+ そのシーケンス長が配列の長さを決定します。
867895
868- If *lock* is ``True`` (the default) then a new lock object is created to
869- synchronize access to the value. If *lock* is a :class:`Lock` or
870- :class:`RLock` object then that will be used to synchronize access to the
871- value. If *lock* is ``False`` then access to the returned object will not be
872- automatically protected by a lock, so it will not necessarily be
873- "process-safe".
896+ *lock* が ``True`` (デフォルト) なら、値へ同期アクセスするために新たな
897+ ロックオブジェクトが作成されます。 *lock* が :class:`Lock` か :class:`RLock`
898+ なら値への同期アクセスに使用されます。 *lock* が ``False`` なら、返された
899+ オブジェクトへのアクセスはロックにより自動的に保護されません。
900+ そのため、必ずしも "プロセスセーフ" ではありません。
874901
875- Note that *lock* is a keyword only argument.
902+ *lock* はキーワード引数でのみ指定することに注意してください。
876903
877- Note that an array of :data:`ctypes.c_char` has *value* and *rawvalue*
878- attributes which allow one to use it to store and retrieve strings.
904+ :data:`ctypes.c_char` の配列は文字列を格納して取り出せる
905+ *value* と *raw* 属性を持っていることを覚えておいてください。
879906
907+..
908+ The :mod:`multiprocessing.sharedctypes` module
909+ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
880910
881-The :mod:`multiprocessing.sharedctypes` module
911+:mod:`multiprocessing.sharedctypes` モジュール
882912 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
883913
884-.. module:: multiprocessing.sharedctypes
914+..
885915 :synopsis: Allocate ctypes objects from shared memory.
886916
887-The :mod:`multiprocessing.sharedctypes` module provides functions for allocating
888-:mod:`ctypes` objects from shared memory which can be inherited by child
889-processes.
917+.. module:: multiprocessing.sharedctypes
918+ :synopsis: 共有メモリから ctypes オブジェクトを割り当てる
890919
920+:mod:`multiprocessing.sharedctypes` モジュールは子プロセスに継承される共有メモリの
921+:mod:`ctypes` オブジェクトを割り当てる関数を提供します。
922+
891923 .. note::
892924
893- Although it is possible to store a pointer in shared memory remember that
894- this will refer to a location in the address space of a specific process.
895- However, the pointer is quite likely to be invalid in the context of a second
896- process and trying to dereference the pointer from the second process may
897- cause a crash.
925+ 共有メモリのポインタを格納することは可能ではありますが、特定プロセスの
926+ アドレス空間の位置を参照するということを覚えておいてください。
927+ しかし、そのポインタは別のプロセスのコンテキストにおいて無効になる確率が高いです。
928+ そして、別のプロセスからそのポインタを逆参照しようとするとクラッシュを引き起こす可能性があります。
898929
899930 .. function:: RawArray(typecode_or_type, size_or_initializer)
900931
901- Return a ctypes array allocated from shared memory.
932+ 共有メモリから割り当てられた ctypes 配列を返します。
902933
903- *typecode_or_type* determines the type of the elements of the returned array:
904- it is either a ctypes type or a one character typecode of the kind used by
905- the :mod:`array` module. If *size_or_initializer* is an integer then it
906- determines the length of the array, and the array will be initially zeroed.
907- Otherwise *size_or_initializer* is a sequence which is used to initialize the
908- array and whose length determines the length of the array.
934+ *typecode_or_type* は返される配列の要素の型を決めます。
935+ それは ctypes の型か :mod:`array` モジュールで使用されるような1文字の型コードかのどちらか一方です。
936+ *size_or_initializer* が整数なら、配列の長さを決定し、その配列はゼロで初期化されます。
937+ 別の使用方法として *size_or_initializer* は配列の初期化に使用されるシーケンスになり、
938+ そのシーケンス長が配列の長さを決定します。
909939
910- Note that setting and getting an element is potentially non-atomic -- use
911- :func:`Array` instead to make sure that access is automatically synchronized
912- using a lock.
940+ 要素を取得したり設定したりすることは潜在的に非アトミックであることに注意してください。
941+ ロックを使用して自動的に同期されたアクセスを保証するには :func:`Array` を使用してください。
913942
914943 .. function:: RawValue(typecode_or_type, *args)
915944
916- Return a ctypes object allocated from shared memory.
945+ 共有メモリから割り当てられた ctypes オブジェクトを返します。
917946
918- *typecode_or_type* determines the type of the returned object: it is either a
919- ctypes type or a one character typecode of the kind used by the :mod:`array`
920- module. */*args* is passed on to the constructor for the type.
947+ *typecode_or_type* は返される型を決めます。
948+ それは ctypes の型か :mod:`array` モジュールで使用されるような1文字の型コードかのどちらか一方です。
949+ *\*args* は型のコンストラクタへ渡されます。
921950
922- Note that setting and getting the value is potentially non-atomic -- use
923- :func:`Value` instead to make sure that access is automatically synchronized
924- using a lock.
951+ 値を取得したり設定したりすることは潜在的に非アトミックであることに注意してください。
952+ ロックを使用して自動的に同期されたアクセスを保証するには :func:`Value` を使用してください。
925953
926- Note that an array of :data:`ctypes.c_char` has ``value`` and ``rawvalue``
927- attributes which allow one to use it to store and retrieve strings -- see
928- documentation for :mod:`ctypes`.
954+ :data:`ctypes.c_char` の配列は文字列を格納して取り出せる
955+ *value* と *raw* 属性を持っていることを覚えておいてください。
956+ 詳細は :mod:`ctypes` を参照してください。
929957
930-.. function:: Array(typecode_or_type, size_or_initializer[, *args[, lock]])
958+.. function:: Array(typecode_or_type, size_or_initializer, *args[, lock])
931959
932- The same as :func:`RawArray` except that depending on the value of *lock* a
933- process-safe synchronization wrapper may be returned instead of a raw ctypes
934- array.
960+ *lock* の値に依存する点を除けば :func:`RawArray` と同様です。
961+ プロセスセーフな同期ラッパーが raw ctypes 配列の代わりに返されるでしょう。
935962
936- If *lock* is ``True`` (the default) then a new lock object is created to
937- synchronize access to the value. If *lock* is a :class:`Lock` or
938- :class:`RLock` object then that will be used to synchronize access to the
939- value. If *lock* is ``False`` then access to the returned object will not be
940- automatically protected by a lock, so it will not necessarily be
941- "process-safe".
963+ *lock* が ``True`` (デフォルト) なら、値へ同期アクセスするために新たな
964+ ロックオブジェクトが作成されます。 *lock* が :class:`Lock` か :class:`RLock`
965+ なら値への同期アクセスに使用されます。 *lock* が ``False`` なら、返された
966+ オブジェクトへのアクセスはロックにより自動的に保護されません。
967+ そのため、必ずしも "プロセスセーフ" ではありません。
942968
943- Note that *lock* is a keyword-only argument.
969+ *lock* はキーワード引数でのみ指定することに注意してください。
944970
945971 .. function:: Value(typecode_or_type, *args[, lock])
946972
947- The same as :func:`RawValue` except that depending on the value of *lock* a
948- process-safe synchronization wrapper may be returned instead of a raw ctypes
949- object.
973+ *lock* の値に依存する点を除けば :func:`RawValue` と同様です。
974+ プロセスセーフな同期ラッパーが ctypes オブジェクトの代わりに返されるでしょう。
950975
951- If *lock* is ``True`` (the default) then a new lock object is created to
952- synchronize access to the value. If *lock* is a :class:`Lock` or
953- :class:`RLock` object then that will be used to synchronize access to the
954- value. If *lock* is ``False`` then access to the returned object will not be
955- automatically protected by a lock, so it will not necessarily be
956- "process-safe".
976+ *lock* が ``True`` (デフォルト) なら、値へ同期アクセスするために新たな
977+ ロックオブジェクトが作成されます。 *lock* が :class:`Lock` か :class:`RLock`
978+ なら値への同期アクセスに使用されます。 *lock* が ``False`` なら、返された
979+ オブジェクトへのアクセスはロックにより自動的に保護されません。
980+ そのため、必ずしも "プロセスセーフ" ではありません。
957981
958- Note that *lock* is a keyword-only argument.
982+ *lock* はキーワード引数でのみ指定することに注意してください。
959983
960984 .. function:: copy(obj)
961985
962- Return a ctypes object allocated from shared memory which is a copy of the
963- ctypes object *obj*.
986+ 共有メモリから割り当てられた ctypes オブジェクト *obj* をコピーしたオブジェクトを返します。
964987
965988 .. function:: synchronized(obj[, lock])
966989
967- Return a process-safe wrapper object for a ctypes object which uses *lock* to
968- synchronize access. If *lock* is ``None`` (the default) then a
969- :class:`multiprocessing.RLock` object is created automatically.
990+ 同期アクセスに *lock* を使用する ctypes オブジェクトのためにプロセスセーフな
991+ ラッパーオブジェクトを返します。 *lock* が ``None`` (デフォルト) なら、
992+ :class:`multiprocessing.RLock` オブジェクトが自動的に作成されます。
970993
971- A synchronized wrapper will have two methods in addition to those of the
972- object it wraps: :meth:`get_obj` returns the wrapped object and
973- :meth:`get_lock` returns the lock object used for synchronization.
994+ 同期ラッパーがラップするオブジェクトに加えて2つのメソッドがあります。
995+ :meth:`get_obj` はラップされたオブジェクトを返します。
996+ :meth:`get_lock` は同期のために使用されるロックオブジェクトを返します。
974997
975- Note that accessing the ctypes object through the wrapper can be a lot slower
976- than accessing the raw ctypes object.
998+ ラッパー経由で ctypes オブジェクトにアクセスすることは
999+ raw ctypes オブジェクトへアクセスするよりずっと遅くなることに注意してください。
9771000
1001+次の表は通常の ctypes 構文で共有メモリから共有 ctypes オブジェクトを作成するための
1002+構文を比較します。
1003+( ``MyStruct`` テーブル内には :class:`ctypes.Structure` のサブクラスがあります。)
9781004
979-The table below compares the syntax for creating shared ctypes objects from
980-shared memory with the normal ctypes syntax. (In the table ``MyStruct`` is some
981-subclass of :class:`ctypes.Structure`.)
982-
983-==================== ========================== ===========================
984-ctypes sharedctypes using type sharedctypes using typecode
985-==================== ========================== ===========================
986-c_double(2.4) RawValue(c_double, 2.4) RawValue('d', 2.4)
1005+==================== ============================ ================================
1006+ctypes type を使用する sharedctypes typecode を使用する sharedctypes
1007+==================== ============================ ================================
1008+c_double(2.4) RawValue(c_double, 2.4) RawValue('d', 2.4)
9871009 MyStruct(4, 6) RawValue(MyStruct, 4, 6)
988-(c_short * 7)() RawArray(c_short, 7) RawArray('h', 7)
989-(c_int * 3)(9, 2, 8) RawArray(c_int, (9, 2, 8)) RawArray('i', (9, 2, 8))
990-==================== ========================== ===========================
1010+(c_short * 7)() RawArray(c_short, 7) RawArray('h', 7)
1011+(c_int * 3)(9, 2, 8) RawArray(c_int, (9, 2, 8)) RawArray('i', (9, 2, 8))
1012+==================== ============================ ================================
9911013
9921014
993-Below is an example where a number of ctypes objects are modified by a child
994-process::
1015+以下に子プロセスが多くの ctypes オブジェクトを変更する例を紹介します。
9951016
1017+::
1018+
9961019 from multiprocessing import Process, Lock
9971020 from multiprocessing.sharedctypes import Value, Array
9981021 from ctypes import Structure, c_double
@@ -1028,8 +1051,10 @@
10281051
10291052 .. highlightlang:: none
10301053
1031-The results printed are ::
1054+結果は以下のように表示されます。
10321055
1056+::
1057+
10331058 49
10341059 0.1111111111111111
10351060 HELLO WORLD
@@ -1043,195 +1068,208 @@
10431068 Managers
10441069 ~~~~~~~~
10451070
1046-Managers provide a way to create data which can be shared between different
1047-processes. A manager object controls a server process which manages *shared
1048-objects*. Other processes can access the shared objects by using proxies.
1071+Manager は別のプロセス間で共有されるデータの作成方法を提供します。
1072+マネージャオブジェクトは *共有オブジェクト* を管理するサーバプロセスを制御します。
1073+他のプロセスはプロキシ経由で共有オブジェクトへアクセスすることができます。
10491074
10501075 .. function:: multiprocessing.Manager()
10511076
1052- Returns a started :class:`~multiprocessing.managers.SyncManager` object which
1053- can be used for sharing objects between processes. The returned manager
1054- object corresponds to a spawned child process and has methods which will
1055- create shared objects and return corresponding proxies.
1077+ プロセス間で共有オブジェクトのために使用される
1078+ :class:`~multiprocessing.managers.SyncManager` オブジェクトを返します。
1079+ 返されたマネージャオブジェクトは生成される子プロセスに対応して、
1080+ 共有オブジェクトを作成するメソッドを持ち、応答プロキシを返します。
10561081
10571082 .. module:: multiprocessing.managers
10581083 :synopsis: Share data between process with shared objects.
10591084
1060-Manager processes will be shutdown as soon as they are garbage collected or
1061-their parent process exits. The manager classes are defined in the
1062-:mod:`multiprocessing.managers` module:
1085+マネージャプロセスは親プロセスが終了するか、ガベージコレクトされると停止します。
1086+マネージャクラスは :mod:`multiprocessing.managers` モジュールで定義されています。
10631087
10641088 .. class:: BaseManager([address[, authkey]])
10651089
1066- Create a BaseManager object.
1090+ BaseManager オブジェクトを作成します。
10671091
1068- Once created one should call :meth:`start` or :meth:`serve_forever` to ensure
1069- that the manager object refers to a started manager process.
1092+ 作成後、マネージャオブジェクトが開始されたマネージャプロセスの参照を保証するために
1093+ :meth:`start` か :meth:`serve_forever` を呼び出します。
10701094
1071- *address* is the address on which the manager process listens for new
1072- connections. If *address* is ``None`` then an arbitrary one is chosen.
1095+ *address* はマネージャプロセスが新たなコネクションを待ち受けるアドレスです。
1096+ *address* が ``None`` の場合、任意のアドレスが設定されます。
10731097
1074- *authkey* is the authentication key which will be used to check the validity
1075- of incoming connections to the server process. If *authkey* is ``None`` then
1076- ``current_process().authkey``. Otherwise *authkey* is used and it
1077- must be a string.
1098+ *authkey* はサーバプロセスへ接続しようとするコネクションの正当性を検証するために
1099+ 使用される認証キーです。
1100+ *authkey* が ``None`` の場合 ``current_process().authkey`` が使用されます。
1101+ *authkey* を使用する場合は文字列でなければなりません。
10781102
10791103 .. method:: start()
10801104
1081- Start a subprocess to start the manager.
1105+ マネージャを開始するためにサブプロセスを開始します。
10821106
10831107 .. method:: serve_forever()
10841108
1085- Run the server in the current process.
1109+ カレントプロセスでサーバを実行します。
10861110
10871111 .. method:: from_address(address, authkey)
10881112
1089- A class method which creates a manager object referring to a pre-existing
1090- server process which is using the given address and authentication key.
1113+ 引数として渡されたアドレスと認証キーを使用して既存のサーバプロセスを参照する
1114+ マネージャオブジェクトを作成するクラスメソッドです。
10911115
1116+ .. method:: get_server()
1117+
1118+ マネージャの制御下にある実際のサーバに相当する :class:`Server` オブジェクトを返します。
1119+ :class:`Server` オブジェクトは :meth:`serve_forever` メソッドをサポートします。
1120+
1121+ >>> from multiprocessing.managers import BaseManager
1122+ >>> m = BaseManager(address=('', 50000), authkey='abc'))
1123+ >>> server = m.get_server()
1124+ >>> s.serve_forever()
1125+
1126+ :class:`Server` はさらに :attr:`address` 属性も持っています。
1127+
1128+ .. method:: connect()
1129+
1130+ ローカルからリモートのマネージャオブジェクトへ接続します。
1131+
1132+ >>> from multiprocessing.managers import BaseManager
1133+ >>> m = BaseManager(address='127.0.0.1', authkey='abc))
1134+ >>> m.connect()
1135+
10921136 .. method:: shutdown()
10931137
1094- Stop the process used by the manager. This is only available if
1095- :meth:`start` has been used to start the server process.
1138+ マネージャが使用するプロセスを停止します。これはサーバプロセスを
1139+ 開始するために :meth:`start` が使用された場合のみ有効です。
10961140
1097- This can be called multiple times.
1141+ これは複数回呼び出すことができます。
10981142
10991143 .. method:: register(typeid[, callable[, proxytype[, exposed[, method_to_typeid[, create_method]]]]])
11001144
1101- A classmethod which can be used for registering a type or callable with
1102- the manager class.
1145+ マネージャクラスで呼び出し可能オブジェクト(callable)や型を登録するために使用されるクラスメソッドです。
11031146
1104- *typeid* is a "type identifier" which is used to identify a particular
1105- type of shared object. This must be a string.
1147+ *typeid* は特に共有オブジェクトの型を識別するために使用される "型識別子" です。
1148+ これは文字列でなければなりません。
11061149
1107- *callable* is a callable used for creating objects for this type
1108- identifier. If a manager instance will be created using the
1109- :meth:`from_address` classmethod or if the *create_method* argument is
1110- ``False`` then this can be left as ``None``.
1150+ *callable* はこの型識別子のオブジェクトを作成するために使用される呼び出し可能オブジェクトです。
1151+ マネージャインスタンスが :meth:`from_address` クラスメソッドを使用して作成されるか、
1152+ *create_method* 引数が ``False`` の場合は ``None`` でも構いません。
11111153
1112- *proxytype* is a subclass of :class:`BaseProxy` which is used to create
1113- proxies for shared objects with this *typeid*. If ``None`` then a proxy
1114- class is created automatically.
1154+ *proxytype* はこの *typeid* で共有オブジェクトのプロキシを作成するために使用される
1155+ :class:`BaseProxy` のサブクラスです。 ``None`` の場合、プロキシクラスは自動的に作成されます。
11151156
1116- *exposed* is used to specify a sequence of method names which proxies for
1117- this typeid should be allowed to access using
1118- :meth:`BaseProxy._callMethod`. (If *exposed* is ``None`` then
1119- :attr:`proxytype._exposed_` is used instead if it exists.) In the case
1120- where no exposed list is specified, all "public methods" of the shared
1121- object will be accessible. (Here a "public method" means any attribute
1122- which has a :meth:`__call__` method and whose name does not begin with
1123- ``'_'``.)
1157+ *exposed* は :meth:`BaseProxy._callMethod` を使用してアクセスされる
1158+ この typeid のプロキシになるメソッド名のシーケンスを指定するために使用されます。
1159+ ( *exposed* が ``None`` の場合 :attr:`proxytype._exposed_` が存在すれば、
1160+ それが代わりに使用されます。) exposed リストが指定されない場合は、
1161+ 共有オブジェクトの全ての "パブリックメソッド" にアクセスされます。
1162+ (ここで言う "パブリックメソッド" は :meth:`__call__` メソッドを持ち、
1163+ ``'_'`` で始まらない名前の属性を意味します。)
11241164
1125- *method_to_typeid* is a mapping used to specify the return type of those
1126- exposed methods which should return a proxy. It maps method names to
1127- typeid strings. (If *method_to_typeid* is ``None`` then
1128- :attr:`proxytype._method_to_typeid_` is used instead if it exists.) If a
1129- method's name is not a key of this mapping or if the mapping is ``None``
1130- then the object returned by the method will be copied by value.
1165+ *method_to_typeid* はプロキシが返す exposed メソッドの型を指定するために
1166+ 使用されるマッピングです。それは typeid 文字列に対してメソッド名をマップします。
1167+ ( *method_to_typeid* が ``None`` の場合 :attr:`proxytype._method_to_typeid_`
1168+ が存在すれば、それが代わりに使用されます。) メソッド名がこのマッピングのキー
1169+ ではないか、マッピングが ``None`` の場合、そのメソッドによって返される
1170+ オブジェクトが値によってコピーされます。
11311171
1132- *create_method* determines whether a method should be created with name
1133- *typeid* which can be used to tell the server process to create a new
1134- shared object and return a proxy for it. By default it is ``True``.
1172+ *create_method* は、新たな共有オブジェクトを作成するためにサーバプロセスへ
1173+ 伝えるのに使用されるメソッドを *typeid* の名前で作成し、そのための
1174+ プロキシを返すかを決定します。デフォルトでは ``True`` です。
11351175
1136- :class:`BaseManager` instances also have one read-only property:
1176+ :class:`BaseManager` インスタンスも読み取り専用属性を1つ持っています。
11371177
11381178 .. attribute:: address
11391179
1140- The address used by the manager.
1180+ マネージャが使用するアドレスです。
11411181
1142-
11431182 .. class:: SyncManager
11441183
1145- A subclass of :class:`BaseManager` which can be used for the synchronization
1146- of processes. Objects of this type are returned by
1147- :func:`multiprocessing.Manager`.
1184+ プロセス間の同期のために使用される :class:`BaseManager` のサブクラスです。
1185+ :func:`multiprocessing.Manager` はこの型のオブジェクトを返します。
11481186
1149- It also supports creation of shared lists and dictionaries.
1187+ また共有リストやディクショナリの作成もサポートします。
11501188
11511189 .. method:: BoundedSemaphore([value])
11521190
1153- Create a shared :class:`threading.BoundedSemaphore` object and return a
1154- proxy for it.
1191+ 共有 :class:`threading.BoundedSemaphore` オブジェクトを作成して、そのプロキシを返します。
11551192
11561193 .. method:: Condition([lock])
11571194
1158- Create a shared :class:`threading.Condition` object and return a proxy for
1159- it.
1195+ 共有 :class:`threading.Condition` オブジェクトを作成して、そのプロキシを返します。
11601196
1161- If *lock* is supplied then it should be a proxy for a
1162- :class:`threading.Lock` or :class:`threading.RLock` object.
1197+ *lock* が提供される場合 :class:`threading.Lock` か
1198+ :class:`threading.RLock` オブジェクトのためのプロキシになります。
11631199
11641200 .. method:: Event()
11651201
1166- Create a shared :class:`threading.Event` object and return a proxy for it.
1202+ 共有 :class:`threading.Event` オブジェクトを作成して、そのプロキシを返します。
11671203
11681204 .. method:: Lock()
11691205
1170- Create a shared :class:`threading.Lock` object and return a proxy for it.
1206+ 共有 :class:`threading.Lock` オブジェクトを作成して、そのプロキシを返します。
11711207
11721208 .. method:: Namespace()
11731209
1174- Create a shared :class:`Namespace` object and return a proxy for it.
1210+ 共有 :class:`Namespace` オブジェクトを作成して、そのプロキシを返します。
11751211
11761212 .. method:: Queue([maxsize])
11771213
1178- Create a shared :class:`Queue.Queue` object and return a proxy for it.
1214+ 共有 :class:`Queue.Queue` オブジェクトを作成して、そのプロキシを返します。
11791215
11801216 .. method:: RLock()
11811217
1182- Create a shared :class:`threading.RLock` object and return a proxy for it.
1218+ 共有 :class:`threading.RLock` オブジェクトを作成して、そのプロキシを返します。
11831219
11841220 .. method:: Semaphore([value])
11851221
1186- Create a shared :class:`threading.Semaphore` object and return a proxy for
1187- it.
1222+ 共有 :class:`threading.Semaphore` オブジェクトを作成して、そのプロキシを返します。
11881223
11891224 .. method:: Array(typecode, sequence)
11901225
1191- Create an array and return a proxy for it.
1226+ 配列を作成して、そのプロキシを返します。
11921227
11931228 .. method:: Value(typecode, value)
11941229
1195- Create an object with a writable ``value`` attribute and return a proxy
1196- for it.
1230+ 書き込み可能な ``value`` 属性を作成して、そのプロキシを返します。
11971231
11981232 .. method:: dict()
11991233 dict(mapping)
12001234 dict(sequence)
12011235
1202- Create a shared ``dict`` object and return a proxy for it.
1236+ 共有 ``dict`` オブジェクトを作成して、そのプロキシを返します。
12031237
12041238 .. method:: list()
12051239 list(sequence)
12061240
1207- Create a shared ``list`` object and return a proxy for it.
1241+ 共有 ``list`` オブジェクトを作成して、そのプロキシを返します。
12081242
12091243
1210-Namespace objects
1211->>>>>>>>>>>>>>>>>
1244+Namespace オブジェクト
1245+>>>>>>>>>>>>>>>>>>>>>>
12121246
1213-A namespace object has no public methods, but does have writable attributes.
1214-Its representation shows the values of its attributes.
1247+Namespace オブジェクトはプライベートなメソッドを持っていますが、書き込み属性を持ちます。
1248+そのオブジェクト表現はその属性の値を表示します。
12151249
1216-However, when using a proxy for a namespace object, an attribute beginning with
1217-``'_'`` will be an attribute of the proxy and not an attribute of the referent::
1250+しかし、Namespace オブジェクトのためにプロキシを使用するとき
1251+``'_'`` が先頭に付く属性はプロキシの属性になり、参照対象の属性にはなりません。
12181252
1253+::
1254+
12191255 >>> manager = multiprocessing.Manager()
12201256 >>> Global = manager.Namespace()
12211257 >>> Global.x = 10
12221258 >>> Global.y = 'hello'
1223- >>> Global._z = 12.3 # this is an attribute of the proxy
1259+ >>> Global._z = 12.3 # これはプロキシの属性です
12241260 >>> print Global
12251261 Namespace(x=10, y='hello')
12261262
12271263
1228-Customized managers
1229->>>>>>>>>>>>>>>>>>>
1264+カスタマイズされたマネージャ
1265+>>>>>>>>>>>>>>>>>>>>>>>>>>>>
12301266
1231-To create one's own manager, one creates a subclass of :class:`BaseManager` and
1232-use the :meth:`~BaseManager.resgister` classmethod to register new types or
1233-callables with the manager class. For example::
1267+独自のマネージャを作成するために :class:`BaseManager` のサブクラスを作成して、
1268+マネージャクラスで呼び出し可能なオブジェクトか新たな型を登録するために
1269+:meth:`~BaseManager.register` クラスメソッドを使用します。
12341270
1271+::
1272+
12351273 from multiprocessing.managers import BaseManager
12361274
12371275 class MathsClass(object):
@@ -1249,41 +1287,49 @@
12491287 manager = MyManager()
12501288 manager.start()
12511289 maths = manager.Maths()
1252- print maths.add(4, 3) # prints 7
1253- print maths.mul(7, 8) # prints 56
1290+ print maths.add(4, 3) # 7 を表示
1291+ print maths.mul(7, 8) # 56 を表示
12541292
12551293
1256-Using a remote manager
1257->>>>>>>>>>>>>>>>>>>>>>
1294+リモートマネージャを使用する
1295+>>>>>>>>>>>>>>>>>>>>>>>>>>>>
12581296
1259-It is possible to run a manager server on one machine and have clients use it
1260-from other machines (assuming that the firewalls involved allow it).
1297+あるマシン上でマネージャサーバを実行して、
1298+他のマシンからそのサーバを使用するクライアントを
1299+持つことができます(ファイアウォールを通過できることが前提)。
12611300
1262-Running the following commands creates a server for a single shared queue which
1263-remote clients can access::
1301+次のコマンドを実行することでリモートクライアントからアクセスを
1302+受け付ける1つの共有キューのためにサーバを作成します。
12641303
1304+::
1305+
12651306 >>> from multiprocessing.managers import BaseManager
12661307 >>> import Queue
12671308 >>> queue = Queue.Queue()
12681309 >>> class QueueManager(BaseManager): pass
12691310 ...
1270- >>> QueueManager.register('getQueue', callable=lambda:queue)
1311+ >>> QueueManager.register('get_queue', callable=lambda:queue)
12711312 >>> m = QueueManager(address=('', 50000), authkey='abracadabra')
1272- >>> m.serveForever()
1313+ >>> s = m.get_server()
1314+ >>> s.serveForever()
12731315
1274-One client can access the server as follows::
1316+あるクライアントからサーバへのアクセスは次のようになります。
12751317
1318+::
1319+
12761320 >>> from multiprocessing.managers import BaseManager
12771321 >>> class QueueManager(BaseManager): pass
12781322 ...
1279- >>> QueueManager.register('getQueue')
1280- >>> m = QueueManager.from_address(address=('foo.bar.org', 50000),
1281- >>> authkey='abracadabra')
1282- >>> queue = m.getQueue()
1323+ >>> QueueManager.register('get_queue')
1324+ >>> m = QueueManager(address=('foo.bar.org', 50000), authkey='abracadabra')
1325+ >>> m.connect()
1326+ >>> queue = m.get_queue()
12831327 >>> queue.put('hello')
12841328
1285-Another client can also use it::
1329+別のクライアントもそれを使用することができます。
12861330
1331+::
1332+
12871333 >>> from multiprocessing.managers import BaseManager
12881334 >>> class QueueManager(BaseManager): pass
12891335 ...
@@ -1293,19 +1339,43 @@
12931339 >>> queue.get()
12941340 'hello'
12951341
1342+ローカルプロセスもそのキューへアクセスすることができます。
1343+クライアント上で上述のコードを使用してアクセスします。
12961344
1297-Proxy Objects
1298-~~~~~~~~~~~~~
1345+::
12991346
1300-A proxy is an object which *refers* to a shared object which lives (presumably)
1301-in a different process. The shared object is said to be the *referent* of the
1302-proxy. Multiple proxy objects may have the same referent.
1347+ >>> from multiprocessing import Process, Queue
1348+ >>> from multiprocessing.managers import BaseManager
1349+ >>> class Worker(Process):
1350+ ... def __init__(self, q):
1351+ ... self.q = q
1352+ ... super(Worker, self).__init__()
1353+ ... def run(self):
1354+ ... self.q.put('local hello')
1355+ ...
1356+ >>> queue = Queue()
1357+ >>> w = Worker(queue)
1358+ >>> w.start()
1359+ >>> class QueueManager(BaseManager): pass
1360+ ...
1361+ >>> QueueManager.register('get_queue', callable=lambda: queue)
1362+ >>> m = QueueManager(address=('', 50000), authkey='abracadabra')
1363+ >>> s = m.get_server()
1364+ >>> s.serve_forever()
13031365
1304-A proxy object has methods which invoke corresponding methods of its referent
1305-(although not every method of the referent will necessarily be available through
1306-the proxy). A proxy can usually be used in most of the same ways that its
1307-referent can::
1366+Proxy オブジェクト
1367+~~~~~~~~~~~~~~~~~~
13081368
1369+プロキシは別のプロセスで(おそらく)有効な共有オブジェクトを *参照する* オブジェクトです。
1370+共有オブジェクトはプロキシの *参照対象* になると言うことができます。
1371+複数のプロキシオブジェクトが同じ参照対象を持つ可能性もあります。
1372+
1373+プロキシオブジェクトはその参照対象が持つ対応メソッドを実行するメソッドを持ちます。
1374+(そうは言っても、参照対象の全てのメソッドが必ずしもプロキシ経由で利用可能ではありません)
1375+プロキシは通常その参照対象ができることと同じ方法で使用されます。
1376+
1377+::
1378+
13091379 >>> from multiprocessing import Manager
13101380 >>> manager = Manager()
13111381 >>> l = manager.list([i*i for i in range(10)])
@@ -1318,18 +1388,19 @@
13181388 >>> l[2:5]
13191389 [4, 9, 16]
13201390
1321-Notice that applying :func:`str` to a proxy will return the representation of
1322-the referent, whereas applying :func:`repr` will return the representation of
1323-the proxy.
1391+プロキシに :func:`str` を適用すると参照対象のオブジェクト表現を返すのに対して、
1392+:func:`repr` を適用するとプロキシのオブジェクト表現を返すことに注意してください。
13241393
1325-An important feature of proxy objects is that they are picklable so they can be
1326-passed between processes. Note, however, that if a proxy is sent to the
1327-corresponding manager's process then unpickling it will produce the referent
1328-itself. This means, for example, that one shared object can contain a second::
1394+プロキシオブジェクトの重要な機能はプロセス間で受け渡し可能な pickle 化ができることです。
1395+しかし、プロキシが対応するマネージャプロセスに対して送信される場合、
1396+そのプロキシを unpickle するとその参照対象を生成することを覚えておいてください。
1397+例えば、これはある共有オブジェクトに別の共有オブジェクトが含められることを意味します。
13291398
1399+::
1400+
13301401 >>> a = manager.list()
13311402 >>> b = manager.list()
1332- >>> a.append(b) # referent of a now contains referent of b
1403+ >>> a.append(b) # a の参照対象に b の参照対象を含める
13331404 >>> print a, b
13341405 [[]] []
13351406 >>> b.append('hello')
@@ -1338,197 +1409,191 @@
13381409
13391410 .. note::
13401411
1341- The proxy types in :mod:`multiprocessing` do nothing to support comparisons
1342- by value. So, for instance, ::
1412+ :mod:`multiprocessing` のプロキシ型は値による比較に対して何もサポートしません。
1413+ そのため、インスタンスでは、
1414+
1415+ ::
13431416
13441417 manager.list([1,2,3]) == [1,2,3]
13451418
1346- will return ``False``. One should just use a copy of the referent instead
1347- when making comparisons.
1419+ は ``False`` が返されます。比較を行いたいときは参照対象のコピーを使用してください。
13481420
13491421 .. class:: BaseProxy
13501422
1351- Proxy objects are instances of subclasses of :class:`BaseProxy`.
1423+ プロキシオブジェクトは :class:`BaseProxy` のサブクラスのインスタンスです。
13521424
1353- .. method:: _call_method(methodname[, args[, kwds]])
1425+ .. method:: _callmethod(methodname[, args[, kwds]])
13541426
1355- Call and return the result of a method of the proxy's referent.
1427+ プロキシの参照対象のメソッドの実行結果を返します。
13561428
1357- If ``proxy`` is a proxy whose referent is ``obj`` then the expression ::
1429+ ``proxy`` がプロキシで、プロキシ内の参照対象が ``obj`` なら、
1430+
1431+ ::
13581432
1359- proxy._call_method(methodname, args, kwds)
1433+ proxy._callmethod(methodname, args, kwds)
13601434
1361- will evaluate the expression ::
1435+ は、
13621436
1437+ ::
1438+
13631439 getattr(obj, methodname)(*args, **kwds)
13641440
1365- in the manager's process.
1441+ マネージャプロセス内のこの式を評価します。
13661442
1367- The returned value will be a copy of the result of the call or a proxy to
1368- a new shared object -- see documentation for the *method_to_typeid*
1369- argument of :meth:`BaseManager.register`.
1443+ 返される値はその呼び出し結果のコピーか、新たな共有オブジェクトに対するプロキシになります。
1444+ 詳細は :meth:`BaseManager.register` の *method_to_typeid* 引数のドキュメントを参照してください。
13701445
1371- If an exception is raised by the call, then then is re-raised by
1372- :meth:`_call_method`. If some other exception is raised in the manager's
1373- process then this is converted into a :exc:`RemoteError` exception and is
1374- raised by :meth:`_call_method`.
1446+ 例外がその呼び出しによって発生する場合 :meth:`_callmethod` によって再発生させます。
1447+ もし他の例外がマネージャプロセスで発生するなら、
1448+ :exc:`RemoteError` 例外に変換されて :meth:`_callmethod` によって発生させます。
13751449
1376- Note in particular that an exception will be raised if *methodname* has
1377- not been *exposed*
1450+ 特に *methodname* が *公開* されていない場合は例外が発生することに注意してください。
13781451
1379- An example of the usage of :meth:`_call_method`::
1452+ :meth:`_callmethod` の使用例になります。
13801453
1454+ ::
1455+
13811456 >>> l = manager.list(range(10))
1382- >>> l._call_method('__len__')
1457+ >>> l._callmethod('__len__')
13831458 10
1384- >>> l._call_method('__getslice__', (2, 7)) # equiv to `l[2:7]`
1459+ >>> l._callmethod('__getslice__', (2, 7)) # `l[2:7]` と等価
13851460 [2, 3, 4, 5, 6]
1386- >>> l._call_method('__getitem__', (20,)) # equiv to `l[20]`
1461+ >>> l._callmethod('__getitem__', (20,)) # `l[20]` と等価
13871462 Traceback (most recent call last):
13881463 ...
13891464 IndexError: list index out of range
13901465
1391- .. method:: _get_value()
1466+ .. method:: _getvalue()
13921467
1393- Return a copy of the referent.
1468+ 参照対象のコピーを返します。
13941469
1395- If the referent is unpicklable then this will raise an exception.
1470+ 参照対象が unpickle 化できるなら例外を発生します。
13961471
13971472 .. method:: __repr__
13981473
1399- Return a representation of the proxy object.
1474+ プロキシオブジェクトのオブジェクト表現を返します。
14001475
14011476 .. method:: __str__
14021477
1403- Return the representation of the referent.
1478+ 参照対象のオブジェクト表現を返します。
14041479
1480+クリーンアップ
1481+>>>>>>>>>>>>>>
14051482
1406-Cleanup
1407->>>>>>>
1483+プロキシオブジェクトは弱参照(weakref)コールバックを使用します。
1484+プロキシオブジェクトがガベージコレクトされるときに
1485+その参照対象が所有するマネージャからその登録を取り消せるようにするためです。
14081486
1409-A proxy object uses a weakref callback so that when it gets garbage collected it
1410-deregisters itself from the manager which owns its referent.
1487+共有オブジェクトはプロキシが参照しなくなったときにマネージャプロセスから削除されます。
14111488
1412-A shared object gets deleted from the manager process when there are no longer
1413-any proxies referring to it.
1489+プロセスプール
1490+~~~~~~~~~~~~~~
14141491
1415-
1416-Process Pools
1417-~~~~~~~~~~~~~
1418-
14191492 .. module:: multiprocessing.pool
14201493 :synopsis: Create pools of processes.
14211494
1422-One can create a pool of processes which will carry out tasks submitted to it
1423-with the :class:`Pool` class.
1495+:class:`Pool` クラスでタスクを実行するプロセスのプールを作成することができます。
14241496
14251497 .. class:: multiprocessing.Pool([processes[, initializer[, initargs]]])
14261498
1427- A process pool object which controls a pool of worker processes to which jobs
1428- can be submitted. It supports asynchronous results with timeouts and
1429- callbacks and has a parallel map implementation.
1499+ プロセスプールオブジェクトはジョブが実行されるようにワーカープロセスのプールを制御します。
1500+ タイムアウトやコールバックで非同期の実行をサポートして、並列 map 実装を持ちます。
14301501
1431- *processes* is the number of worker processes to use. If *processes* is
1432- ``None`` then the number returned by :func:`cpu_count` is used. If
1433- *initializer* is not ``None`` then each worker process will call
1434- ``initializer(*initargs)`` when it starts.
1502+ *processes* は使用するワーカープロセスの数です。 *processes* が ``None`` の場合
1503+ :func:`cpu_count` が返す数を使用します。 *initializer* が ``None`` の場合、
1504+ 各ワーカープロセスが開始時に ``initializer(*initargs)`` を呼び出します。
14351505
14361506 .. method:: apply(func[, args[, kwds]])
14371507
1438- Equivalent of the :func:`apply` builtin function. It blocks till the
1439- result is ready.
1508+ :func:`apply` 組み込み関数と同じです。その結果を返せるようになるまでブロックします。
14401509
14411510 .. method:: apply_async(func[, args[, kwds[, callback]]])
14421511
1443- A variant of the :meth:`apply` method which returns a result object.
1512+ :meth:`apply` メソッドの一種で結果オブジェクトを返します。
14441513
1445- If *callback* is specified then it should be a callable which accepts a
1446- single argument. When the result becomes ready *callback* is applied to
1447- it (unless the call failed). *callback* should complete immediately since
1448- otherwise the thread which handles the results will get blocked.
1514+ *callback* が指定された場合、1つの引数を受け取って呼び出されます。
1515+ その結果を返せるようになったときに *callback* が結果オブジェクトに対して
1516+ (その呼び出しが失敗しない限り)適用されます。
1517+ その結果を扱う別スレッドはブロックされるので *callback* はすぐに終了します。
14491518
14501519 .. method:: map(func, iterable[, chunksize])
14511520
1452- A parallel equivalent of the :func:`map` builtin function. It blocks till
1453- the result is ready.
1521+ 並列な :func:`map` 組み込み関数と同じです( *iterable* な引数を1つだけサポートします)。
1522+ その結果を返せるようになるまでブロックします。
14541523
1455- This method chops the iterable into a number of chunks which it submits to
1456- the process pool as separate tasks. The (approximate) size of these
1457- chunks can be specified by setting *chunksize* to a positive integer.
1524+ このメソッドは独立したタスクのようにプロセスプールに対して実行するチャンク数に分割します。
1525+ チャンク(概算)サイズは *chunksize* に正の整数を指定することで行います。
14581526
14591527 .. method:: map_async(func, iterable[, chunksize[, callback]])
14601528
1461- A variant of the :meth:`map` method which returns a result object.
1529+ :meth:`map` メソッドの一種で結果オブジェクトを返します。
14621530
1463- If *callback* is specified then it should be a callable which accepts a
1464- single argument. When the result becomes ready *callback* is applied to
1465- it (unless the call failed). *callback* should complete immediately since
1466- otherwise the thread which handles the results will get blocked.
1531+ *callback* が指定された場合、1つの引数を受け取って呼び出されます。
1532+ その結果を返せるようになったときに *callback* が結果オブジェクトに対して
1533+ (その呼び出しが失敗しない限り)適用されます。
1534+ その結果を扱う別スレッドはブロックされるので *callback* はすぐに終了します。
14671535
14681536 .. method:: imap(func, iterable[, chunksize])
14691537
1470- An equivalent of :func:`itertools.imap`.
1538+ :func:`itertools.imap` と同じです。
14711539
1472- The *chunksize* argument is the same as the one used by the :meth:`.map`
1473- method. For very long iterables using a large value for *chunksize* can
1474- make make the job complete **much** faster than using the default value of
1475- ``1``.
1540+ *chunksize* 引数は :meth:`map` メソッドで使用されるものと同じです。
1541+ 引数 iterable がとても大きいなら *chunksize* に大きな値を指定して使用する方が
1542+ デフォルト値の ``1`` を使用するよりもジョブの完了が **かなり** 速くなります。
14761543
1477- Also if *chunksize* is ``1`` then the :meth:`next` method of the iterator
1478- returned by the :meth:`imap` method has an optional *timeout* parameter:
1479- ``next(timeout)`` will raise :exc:`multiprocessing.TimeoutError` if the
1480- result cannot be returned within *timeout* seconds.
1544+ また *chunksize* が ``1`` の場合 :meth:`imap` メソッドが返すイテレータの
1545+ :meth:`next` メソッドはオプションで *timeout* パラメータを持ちます。
1546+ ``next(timeout)`` は、その結果が *timeout* 秒以内に返されないときに
1547+ :exc:`multiprocessing.TimeoutError` を発生させます。
14811548
14821549 .. method:: imap_unordered(func, iterable[, chunksize])
14831550
1484- The same as :meth:`imap` except that the ordering of the results from the
1485- returned iterator should be considered arbitrary. (Only when there is
1486- only one worker process is the order guaranteed to be "correct".)
1551+ イテレータが返す結果の順番が任意の順番で良いと見なされることを除けば :meth:`imap` と同じです。
1552+ (ワーカープロセスが1つしかない場合のみ "正しい" 順番になることが保証されます。)
14871553
14881554 .. method:: close()
14891555
1490- Prevents any more tasks from being submitted to the pool. Once all the
1491- tasks have been completed the worker processes will exit.
1556+ これ以上プールでタスクが実行されないようにします。
1557+ 全てのタスクが完了した後でワーカープロセスが終了します。
14921558
14931559 .. method:: terminate()
14941560
1495- Stops the worker processes immediately without completing outstanding
1496- work. When the pool object is garbage collected :meth:`terminate` will be
1497- called immediately.
1561+ 実行中の処理を完了させずにワーカープロセスをすぐに停止します。
1562+ プールオブジェクトがガベージコレクトされるときに :meth:`terminate` が呼び出されます。
14981563
14991564 .. method:: join()
15001565
1501- Wait for the worker processes to exit. One must call :meth:`close` or
1502- :meth:`terminate` before using :meth:`join`.
1566+ ワーカープロセスが終了するのを待ちます。 :meth:`join` を使用する前に
1567+ :meth:`close` か :meth:`terminate` を呼び出さなければなりません。
15031568
1504-
15051569 .. class:: AsyncResult
15061570
1507- The class of the result returned by :meth:`Pool.apply_async` and
1508- :meth:`Pool.map_async`.
1571+ :meth:`Pool.apply_async` や :meth:`Pool.map_async` で返される結果のクラスです。
15091572
1510- .. method:: get([timeout)
1573+ .. method:: get([timeout])
15111574
1512- Return the result when it arrives. If *timeout* is not ``None`` and the
1513- result does not arrive within *timeout* seconds then
1514- :exc:`multiprocessing.TimeoutError` is raised. If the remote call raised
1515- an exception then that exception will be reraised by :meth:`get`.
1575+ 結果を受け取ったときに返します。 *timeout* が ``None`` ではなくて、
1576+ その結果が *timeout* 秒以内に受け取れない場合
1577+ :exc:`multiprocessing.TimeoutError` が発生します。
1578+ リモートの呼び出しが例外を発生させる場合、その例外は :meth:`get` が再発生させます。
15161579
15171580 .. method:: wait([timeout])
15181581
1519- Wait until the result is available or until *timeout* seconds pass.
1582+ その結果が有効になるか *timeout* 秒経つまで待ちます。
15201583
15211584 .. method:: ready()
15221585
1523- Return whether the call has completed.
1586+ その呼び出しが完了しているかどうかを返します。
15241587
15251588 .. method:: successful()
15261589
1527- Return whether the call completed without raising an exception. Will
1528- raise :exc:`AssertionError` if the result is not ready.
1590+ その呼び出しが例外を発生させることなく完了したかどうかを返します。
1591+ その結果が返せる状態でない場合 :exc:`AssertionError` が発生します。
15291592
1530-The following example demonstrates the use of a pool::
1593+次の例はプールの使用例を紹介します。
15311594
1595+::
1596+
15321597 from multiprocessing import Pool
15331598
15341599 def f(x):
@@ -1535,21 +1600,21 @@
15351600 return x*x
15361601
15371602 if __name__ == '__main__':
1538- pool = Pool(processes=4) # start 4 worker processes
1603+ pool = Pool(processes=4) # 4つのワーカープロセスで開始
15391604
1540- result = pool.applyAsync(f, (10,)) # evaluate "f(10)" asynchronously
1541- print result.get(timeout=1) # prints "100" unless your computer is *very* slow
1605+ result = pool.apply_async(f, (10,)) # 非同期で "f(10)" を評価
1606+ print result.get(timeout=1) # あなたのコンピュータが *かなり* 遅くない限りは "100" を表示
15421607
1543- print pool.map(f, range(10)) # prints "[0, 1, 4,..., 81]"
1608+ print pool.map(f, range(10)) # "[0, 1, 4,..., 81]" を表示
15441609
15451610 it = pool.imap(f, range(10))
1546- print it.next() # prints "0"
1547- print it.next() # prints "1"
1548- print it.next(timeout=1) # prints "4" unless your computer is *very* slow
1611+ print it.next() # "0" を表示
1612+ print it.next() # "1" を表示
1613+ print it.next(timeout=1) # あなたのコンピュータが *かなり* 遅くない限りは "4" を表示
15491614
15501615 import time
1551- result = pool.applyAsync(time.sleep, (10,))
1552- print result.get(timeout=1) # raises TimeoutError
1616+ result = pool.apply_async(time.sleep, (10,))
1617+ print result.get(timeout=1) # TimeoutError を発生
15531618
15541619
15551620 .. _multiprocessing-listeners-clients:
@@ -1560,117 +1625,114 @@
15601625 .. module:: multiprocessing.connection
15611626 :synopsis: API for dealing with sockets.
15621627
1563-Usually message passing between processes is done using queues or by using
1564-:class:`Connection` objects returned by :func:`Pipe`.
1628+通常、プロセス間でメッセージを渡すにはキューを使用するか
1629+:func:`Pipe` が返す :class:`Connection` オブジェクトを使用します。
15651630
1566-However, the :mod:`multiprocessing.connection` module allows some extra
1567-flexibility. It basically gives a high level message oriented API for dealing
1568-with sockets or Windows named pipes, and also has support for *digest
1569-authentication* using the :mod:`hmac` module.
1631+しかし :mod:`multiprocessing.connection` モジュールはさらに柔軟な仕組みがあります。
1632+基本的にはソケットもしくは Windows の名前付きパイプを扱う
1633+高レベルのメッセージ指向 API を提供して :mod:`hmac` モジュールを
1634+使用して *ダイジェスト認証* もサポートします。
15701635
1571-
15721636 .. function:: deliver_challenge(connection, authkey)
15731637
1574- Send a randomly generated message to the other end of the connection and wait
1575- for a reply.
1638+ ランダム生成したメッセージをコネクションの相手側へ送信して応答を待ちます。
15761639
1577- If the reply matches the digest of the message using *authkey* as the key
1578- then a welcome message is sent to the other end of the connection. Otherwise
1579- :exc:`AuthenticationError` is raised.
1640+ その応答がキーとして *authkey* を使用するメッセージのダイジェストと一致する場合、
1641+ コネクションの相手側へ歓迎メッセージを送信します。
1642+ そうでなければ :exc:`AuthenticationError` を発生させます。
15801643
15811644 .. function:: answerChallenge(connection, authkey)
15821645
1583- Receive a message, calculate the digest of the message using *authkey* as the
1584- key, and then send the digest back.
1646+ メッセージを受信して、そのキーとして *authkey* を使用するメッセージの
1647+ ダイジェストを計算し、ダイジェストを送り返します。
15851648
1586- If a welcome message is not received, then :exc:`AuthenticationError` is
1587- raised.
1649+ 歓迎メッセージを受け取れない場合 :exc:`AuthenticationError` が発生します。
15881650
15891651 .. function:: Client(address[, family[, authenticate[, authkey]]])
15901652
1591- Attempt to set up a connection to the listener which is using address
1592- *address*, returning a :class:`~multiprocessing.Connection`.
1653+ *address* で渡したアドレスを使用するリスナーに対してコネクションを
1654+ 確立しようとして :class:`~multiprocessing.Connection` を返します。
15931655
1594- The type of the connection is determined by *family* argument, but this can
1595- generally be omitted since it can usually be inferred from the format of
1596- *address*. (See :ref:`multiprocessing-address-formats`)
1656+ コネクション種別は *family* 引数で決定しますが、一般的には *address* の
1657+ フォーマットから推測できるので、これは指定されません。
1658+ ( :ref:`multiprocessing-address-formats` を参照してください)
15971659
1598- If *authentication* is ``True`` or *authkey* is a string then digest
1599- authentication is used. The key used for authentication will be either
1600- *authkey* or ``current_process().authkey)`` if *authkey* is ``None``.
1601- If authentication fails then :exc:`AuthenticationError` is raised. See
1602- :ref:`multiprocessing-auth-keys`.
1660+ *authentication* が ``True`` か *authkey* が文字列の場合、
1661+ ダイジェスト認証が使用されます。認証に使用されるキーは *authkey* 、
1662+ 又は *authkey* が ``None`` の場合は ``current_process().authkey`` のどちらかです。
1663+ 認証が失敗した場合 :exc:`AuthenticationError` が発生します。
1664+ :ref:`multiprocessing-auth-keys` を参照してください。
16031665
16041666 .. class:: Listener([address[, family[, backlog[, authenticate[, authkey]]]]])
16051667
1606- A wrapper for a bound socket or Windows named pipe which is 'listening' for
1607- connections.
1668+ コネクションを '待ち受ける' 束縛されたソケットか Windows の名前付きパイプのラッパです。
16081669
1609- *address* is the address to be used by the bound socket or named pipe of the
1610- listener object.
1670+ *address* はリスナーオブジェクトの束縛されたソケットか名前付きパイプが使用するアドレスです。
16111671
1612- *family* is the type of socket (or named pipe) to use. This can be one of
1613- the strings ``'AF_INET'`` (for a TCP socket), ``'AF_UNIX'`` (for a Unix
1614- domain socket) or ``'AF_PIPE'`` (for a Windows named pipe). Of these only
1615- the first is guaranteed to be available. If *family* is ``None`` then the
1616- family is inferred from the format of *address*. If *address* is also
1617- ``None`` then a default is chosen. This default is the family which is
1618- assumed to be the fastest available. See
1619- :ref:`multiprocessing-address-formats`. Note that if *family* is
1620- ``'AF_UNIX'`` and address is ``None`` then the socket will be created in a
1621- private temporary directory created using :func:`tempfile.mkstemp`.
1672+ .. note::
16221673
1623- If the listener object uses a socket then *backlog* (1 by default) is passed
1624- to the :meth:`listen` method of the socket once it has been bound.
1674+ '0.0.0.0' のアドレスを使用する場合、Windows 上の終点へ接続することができません。
1675+ 終点へ接続したい場合は '127.0.0.1' を使用すべきです。
16251676
1626- If *authenticate* is ``True`` (``False`` by default) or *authkey* is not
1627- ``None`` then digest authentication is used.
1677+ *family* は使用するソケット(名前付きパイプ)の種別です。
1678+ これは ``'AF_INET'`` (TCP ソケット), ``'AF_UNIX'`` (Unix ドメインソケット)
1679+ 又は ``'AF_PIPE'`` (Windows 名前付きパイプ) という文字列のどれか1つになります。
1680+ これらのうち ``'AF_INET'`` のみが利用可能であることが保証されています。
1681+ *family* が ``None`` の場合 *address* のフォーマットから推測されたものが使用されます。
1682+ *address* も ``None`` の場合はデフォルトが選択されます。
1683+ 詳細は :ref:`multiprocessing-address-formats` を参照してください。
1684+ *family* が ``'AF_UNIX'`` で *address* が ``None`` の場合 :func:`tempfile.mkstemp` を
1685+ 使用して作成されたプライベートな一時ディレクトリにソケットが作成されます。
16281686
1629- If *authkey* is a string then it will be used as the authentication key;
1630- otherwise it must be *None*.
1687+ リスナーオブジェクトがソケットを使用する場合、ソケットに束縛されるときに
1688+ *backlog* (デフォルトでは1つ) がソケットの :meth:`listen` メソッドに対して渡されます。
16311689
1632- If *authkey* is ``None`` and *authenticate* is ``True`` then
1633- ``current_process().authkey`` is used as the authentication key. If
1634- *authkey* is ``None`` and *authentication* is ``False`` then no
1635- authentication is done. If authentication fails then
1636- :exc:`AuthenticationError` is raised. See :ref:`multiprocessing-auth-keys`.
1690+ *authentication* が ``True`` (デフォルトでは ``False`` ) か
1691+ *authkey* が ``None`` ではない場合、ダイジェスト認証が使用されます。
16371692
1693+ *authkey* が文字列の場合、認証キーとして使用されます。そうでない場合は *None* でなければいけません。
1694+
1695+ *authkey* が ``None`` 且つ *authenticate* が ``True`` の場合
1696+ ``current_process().authkey`` が認証キーとして使用されます。
1697+ *authkey* が ``None`` 且つ *authentication* が ``False`` の場合、認証は行われません。
1698+ もし認証が失敗した場合 :exc:`AuthenticationError` が発生します。
1699+ 詳細 :ref:`multiprocessing-auth-keys` を参照してください。
1700+
16381701 .. method:: accept()
16391702
1640- Accept a connection on the bound socket or named pipe of the listener
1641- object and return a :class:`Connection` object. If authentication is
1642- attempted and fails, then :exc:`AuthenticationError` is raised.
1703+ リスナーオブジェクトの名前付きパイプか束縛されたソケット上でコネクションを
1704+ 受け付けて :class:`Connection` オブジェクトを返します。
1705+ 認証が失敗した場合 :exc:`AuthenticationError` が発生します。
16431706
16441707 .. method:: close()
16451708
1646- Close the bound socket or named pipe of the listener object. This is
1647- called automatically when the listener is garbage collected. However it
1648- is advisable to call it explicitly.
1709+ リスナーオブジェクトの名前付きパイプか束縛されたソケットをクローズします。
1710+ これはリスナーがガベージコレクトされるときに自動的に呼ばれます。
1711+ そうは言っても、明示的に close() を呼び出す方が望ましいです。
16491712
1650- Listener objects have the following read-only properties:
1713+ リスナーオブジェクトは次の読み取り専用属性を持っています。
16511714
16521715 .. attribute:: address
16531716
1654- The address which is being used by the Listener object.
1717+ リスナーオブジェクトが使用中のアドレスです。
16551718
16561719 .. attribute:: last_accepted
16571720
1658- The address from which the last accepted connection came. If this is
1659- unavailable then it is ``None``.
1721+ 最後にコネクションを受け付けたアドレスです。
1722+ 有効なアドレスがない場合は ``None`` になります。
16601723
1724+このモジュールは2つの例外を定義します。
16611725
1662-The module defines two exceptions:
1663-
16641726 .. exception:: AuthenticationError
16651727
1666- Exception raised when there is an authentication error.
1728+ 認証エラーが起こったときに例外が発生します。
16671729
1730+**例**
16681731
1669-**Examples**
1732+次のサーバコードは認証キーとして ``'secret password'`` を使用するリスナーを作成します。
1733+このサーバはコネクションを待ってクライアントへデータを送信します。
16701734
1671-The following server code creates a listener which uses ``'secret password'`` as
1672-an authentication key. It then waits for a connection and sends some data to
1673-the client::
1735+::
16741736
16751737 from multiprocessing.connection import Listener
16761738 from array import array
@@ -1690,9 +1752,10 @@
16901752 conn.close()
16911753 listener.close()
16921754
1693-The following code connects to the server and receives some data from the
1694-server::
1755+次のコードはサーバへ接続して、サーバからデータを受信します。
16951756
1757+::
1758+
16961759 from multiprocessing.connection import Client
16971760 from array import array
16981761
@@ -1712,171 +1775,210 @@
17121775
17131776 .. _multiprocessing-address-formats:
17141777
1715-Address Formats
1716->>>>>>>>>>>>>>>
1778+アドレスフォーマット
1779+>>>>>>>>>>>>>>>>>>>>
17171780
1718-* An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where
1719- *hostname* is a string and *port* is an integer.
1781+* ``'AF_INET'`` アドレスは ``(hostname, port)`` のタプルになります。
1782+ *hostname* は文字列で *port* は整数です。
17201783
1721-* An ``'AF_UNIX'`` address is a string representing a filename on the
1722- filesystem.
1784+* ``'AF_UNIX'`` アドレスはファイルシステム上のファイル名の文字列です。
17231785
1724-* An ``'AF_PIPE'`` address is a string of the form
1725- ``r'\\\\.\\pipe\\PipeName'``. To use :func:`Client` to connect to a named
1726- pipe on a remote computer called ServerName* one should use an address of the
1727- form ``r'\\\\ServerName\\pipe\\PipeName'`` instead.
1786+* ``'AF_PIPE'`` アドレスは :samp:`r'\\\\.\\pipe\\{PipeName}'` の文字列です。
1787+ *ServerName* というリモートコンピュータ上の名前付きパイプに接続するために
1788+ :func:`Client` を使用するには、代わりに
1789+ :samp:`r'\\\\{ServerName}\\pipe\\{PipeName}'` のアドレスを使用すべきです。
17281790
1729-Note that any string beginning with two backslashes is assumed by default to be
1730-an ``'AF_PIPE'`` address rather than an ``'AF_UNIX'`` address.
1791+デフォルトでは、2つのバックスラッシュで始まる文字列は ``'AF_UNIX'`` よりも
1792+``'AF_PIPE'`` として推測されることに注意してください。
17311793
1732-
17331794 .. _multiprocessing-auth-keys:
17341795
1735-Authentication keys
1736-~~~~~~~~~~~~~~~~~~~
1796+認証キー
1797+~~~~~~~~
17371798
1738-When one uses :meth:`Connection.recv`, the data received is automatically
1739-unpickled. Unfortunately unpickling data from an untrusted source is a security
1740-risk. Therefore :class:`Listener` and :func:`Client` use the :mod:`hmac` module
1741-to provide digest authentication.
1799+:meth:`Connection.recv` を使用するとき、データは自動的に unpickle されて受信します。
1800+信頼できない接続元からのデータを unpickle することはセキュリティリスクがあります。
1801+そのため :class:`Listener` や :func:`Client` はダイジェスト認証を提供するために
1802+:mod:`hmac` モジュールを使用します。
17421803
1743-An authentication key is a string which can be thought of as a password: once a
1744-connection is established both ends will demand proof that the other knows the
1745-authentication key. (Demonstrating that both ends are using the same key does
1746-**not** involve sending the key over the connection.)
1804+認証キーはパスワードとして見なされる文字列です。
1805+コネクションが確立すると、双方の終点で正しい接続先であることを証明するために
1806+知っているお互いの認証キーを要求します。
1807+(双方の終点が同じキーを使用して通信しようとしても、
1808+コネクション上でそのキーを送信することは **できません** 。)
17471809
1748-If authentication is requested but do authentication key is specified then the
1749-return value of ``current_process().authkey`` is used (see
1750-:class:`~multiprocessing.Process`). This value will automatically inherited by
1751-any :class:`~multiprocessing.Process` object that the current process creates.
1752-This means that (by default) all processes of a multi-process program will share
1753-a single authentication key which can be used when setting up connections
1754-between the themselves.
1810+認証が要求されて認証キーが指定されている場合
1811+``current_process().authkey`` の返す値が使用されます。
1812+(詳細は :class:`~multiprocessing.Process` を参照してください。)
1813+この値はカレントプロセスを作成する :class:`~multiprocessing.Process`
1814+オブジェクトによって自動的に継承されます。
1815+これは(デフォルトでは)複数プロセスのプログラムの全プロセスが相互にコネクションを
1816+確立するときに使用される1つの認証キーを共有することを意味します。
17551817
1756-Suitable authentication keys can also be generated by using :func:`os.urandom`.
1818+適当な認証キーを :func:`os.urandom` を使用して生成することもできます。
17571819
1820+ロギング
1821+~~~~~~~~
17581822
1759-Logging
1760-~~~~~~~
1823+ロギングのために幾つかの機能が利用可能です。しかし :mod:`logging` パッケージは、
1824+(ハンドラ種別に依存して)違うプロセスからのメッセージがごちゃ混ぜになるので、
1825+プロセスの共有ロックを使用しないことに注意してください。
17611826
1762-Some support for logging is available. Note, however, that the :mod:`logging`
1763-package does not use process shared locks so it is possible (depending on the
1764-handler type) for messages from different processes to get mixed up.
1765-
17661827 .. currentmodule:: multiprocessing
17671828 .. function:: get_logger()
17681829
1769- Returns the logger used by :mod:`multiprocessing`. If necessary, a new one
1770- will be created.
1830+ :mod:`multiprocessing` が使用するロガーを返します。必要に応じて新たなロガーを作成します。
17711831
1772- When first created the logger has level :data:`logging.NOTSET` and has a
1773- handler which sends output to :data:`sys.stderr` using format
1774- ``'[%(levelname)s/%(processName)s] %(message)s'``. (The logger allows use of
1775- the non-standard ``'%(processName)s'`` format.) Message sent to this logger
1776- will not by default propagate to the root logger.
1832+ 最初に作成するとき、ロガーはレベルに :data:`logging.NOTSET` が設定されていて
1833+ デフォルトハンドラがありません。
1834+ このロガーへ送られるメッセージはデフォルトではルートロガーへ伝播されません。
17771835
1778- Note that on Windows child processes will only inherit the level of the
1779- parent process's logger -- any other customization of the logger will not be
1780- inherited.
1836+ Windows 上では子プロセスが親プロセスのロガーレベルを継承しないことに注意してください。
1837+ さらにその他のロガーのカスタマイズ内容も全て継承されません。
17811838
1782-Below is an example session with logging turned on::
1839+.. currentmodule:: multiprocessing
1840+.. function:: log_to_stderr()
17831841
1784- >>> import processing, logging
1785- >>> logger = processing.getLogger()
1842+ この関数は :func:`get_logger` に対する呼び出しを実行しますが、
1843+ get_logger によって作成されるロガーを返すことに加えて、
1844+ ``'[%(levelname)s/%(processName)s] %(message)s'`` のフォーマットを使用して
1845+ :data:`sys.stderr` へ出力を送るハンドラを追加します。
1846+
1847+以下にロギングを有効にした例を紹介します。
1848+
1849+::
1850+
1851+ >>> import multiprocessing, logging
1852+ >>> logger = multiprocessing.log_to_stderr()
17861853 >>> logger.setLevel(logging.INFO)
17871854 >>> logger.warning('doomed')
17881855 [WARNING/MainProcess] doomed
1789- >>> m = processing.Manager()
1856+ >>> m = multiprocessing.Manager()
17901857 [INFO/SyncManager-1] child process calling self.run()
1791- [INFO/SyncManager-1] manager bound to '\\\\.\\pipe\\pyc-2776-0-lj0tfa'
1858+ [INFO/SyncManager-1] created temp directory /.../pymp-Wh47O_
1859+ [INFO/SyncManager-1] manager serving at '/.../listener-lWsERs'
17921860 >>> del m
17931861 [INFO/MainProcess] sending shutdown message to manager
17941862 [INFO/SyncManager-1] manager exiting with exitcode 0
17951863
1864+これらの2つのロギング関数があることに加えて、
1865+multiprocessing モジュールも2つの追加ロギングレベル属性を提供します。
1866+それは :const:`SUBWARNING` と :const:`SUBDEBUG` です。
1867+次の表は通常のレベル階層にうまく適合していることを表します。
17961868
1797-The :mod:`multiprocessing.dummy` module
1869++----------------+----------------+
1870+| Level | Numeric value |
1871++================+================+
1872+| ``SUBWARNING`` | 25 |
1873++----------------+----------------+
1874+| ``SUBDEBUG`` | 5 |
1875++----------------+----------------+
1876+
1877+完全なロギングレベルの表については :mod:`logging` モジュールを参照してください。
1878+
1879+こういった追加のロギングレベルは主に multiprocessing モジュールの
1880+信頼できるデバッグメッセージのために使用されます。
1881+以下に上述の例に :const:`SUBDEBUG` を有効にしたものを紹介します。
1882+
1883+::
1884+
1885+ >>> import multiprocessing, logging
1886+ >>> logger = multiprocessing.log_to_stderr()
1887+ >>> logger.setLevel(multiprocessing.SUBDEBUG)
1888+ >>> logger.warning('doomed')
1889+ [WARNING/MainProcess] doomed
1890+ >>> m = multiprocessing.Manager()
1891+ [INFO/SyncManager-1] child process calling self.run()
1892+ [INFO/SyncManager-1] created temp directory /.../pymp-djGBXN
1893+ [INFO/SyncManager-1] manager serving at '/.../pymp-djGBXN/listener-knBYGe'
1894+ >>> del m
1895+ [SUBDEBUG/MainProcess] finalizer calling ...
1896+ [INFO/MainProcess] sending shutdown message to manager
1897+ [DEBUG/SyncManager-1] manager received shutdown message
1898+ [SUBDEBUG/SyncManager-1] calling <Finalize object, callback=unlink, ...
1899+ [SUBDEBUG/SyncManager-1] finalizer calling <built-in function unlink> ...
1900+ [SUBDEBUG/SyncManager-1] calling <Finalize object, dead>
1901+ [SUBDEBUG/SyncManager-1] finalizer calling <function rmtree at 0x5aa730> ...
1902+ [INFO/SyncManager-1] manager exiting with exitcode 0
1903+
1904+:mod:`multiprocessing.dummy` モジュール
17981905 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
17991906
18001907 .. module:: multiprocessing.dummy
18011908 :synopsis: Dumb wrapper around threading.
18021909
1803-:mod:`multiprocessing.dummy` replicates the API of :mod:`multiprocessing` but is
1804-no more than a wrapper around the :mod:`threading` module.
1910+:mod:`multiprocessing.dummy` は :mod:`multiprocessing` の API を複製しますが
1911+:mod:`threading` モジュールのラッパーでしかありません。
18051912
1806-
18071913 .. _multiprocessing-programming:
18081914
1809-Programming guidelines
1810-----------------------
1915+プログラミングガイドライン
1916+--------------------------
18111917
1812-There are certain guidelines and idioms which should be adhered to when using
1813-:mod:`multiprocessing`.
1918+:mod:`multiprocessing` を使用するときに守るべき確かなガイドラインとイディオムです。
18141919
1920+全てのプラットホーム
1921+~~~~~~~~~~~~~~~~~~~~
18151922
1816-All platforms
1817-~~~~~~~~~~~~~
1923+共有状態を避ける
18181924
1819-Avoid shared state
1925+ できるだけプロセス間で巨大なデータを移動することは避けるようにすべきです。
18201926
1821- As far as possible one should try to avoid shifting large amounts of data
1822- between processes.
1927+ :mod:`threading` モジュールのプリミティブな低レベルの同期を使用するよりも、
1928+ キューかパイプをプロセス間通信に使用することがおそらく最善の方法です。
18231929
1824- It is probably best to stick to using queues or pipes for communication
1825- between processes rather than using the lower level synchronization
1826- primitives from the :mod:`threading` module.
1930+pickle 機能
18271931
1828-Picklability
1932+ プロキシのメソッドへの引数は pickle 化できることを保証します。
18291933
1830- Ensure that the arguments to the methods of proxies are picklable.
1934+プロキシのスレッドセーフ
18311935
1832-Thread safety of proxies
1936+ プロキシオブジェクトをロックで保護しない限り1つ以上のスレッドから使用してはいけません。
18331937
1834- Do not use a proxy object from more than one thread unless you protect it
1835- with a lock.
1938+ (違うプロセスで *同じ* プロキシを使用することは問題ではありません。)
18361939
1837- (There is never a problem with different processes using the *same* proxy.)
1940+ゾンビプロセスを join する
18381941
1839-Joining zombie processes
1942+ Unix 上ではプロセスが終了したときに join しないと、そのプロセスはゾンビになります。
1943+ 新たなプロセスが開始する(又は :func:`active_children` が呼ばれる)ときに、
1944+ join されていない全ての完了プロセスが join されるので、
1945+ あまり多くにはならないでしょう。また、終了したプロセスの
1946+ :meth:`Process.is_alive` はそのプロセスを join します。
1947+ そうは言っても、自分で開始した全てのプロセスを明示的に join することは
1948+ おそらく良いプラクティスです。
18401949
1841- On Unix when a process finishes but has not been joined it becomes a zombie.
1842- There should never be very many because each time a new process starts (or
1843- :func:`active_children` is called) all completed processes which have not
1844- yet been joined will be joined. Also calling a finished process's
1845- :meth:`Process.is_alive` will join the process. Even so it is probably good
1846- practice to explicitly join all the processes that you start.
1950+pickle/unpickle より継承する方が良い
18471951
1848-Better to inherit than pickle/unpickle
1952+ Windows 上では :mod:`multiprocessing` の多くの型を子プロセスが使用するために
1953+ pickle 化する必要があります。しかし、パイプやキューを使用する他のプロセスへ
1954+ 共有オブジェクトを送ることは一般的に避けるべきです。その代わり、どこかに
1955+ 作成された共有リソースへアクセスが必要なプロセスは他のプロセスから
1956+ 継承できるようにそのプログラムを修正すべきです。
18491957
1850- On Windows many types from :mod:`multiprocessing` need to be picklable so
1851- that child processes can use them. However, one should generally avoid
1852- sending shared objects to other processes using pipes or queues. Instead
1853- you should arrange the program so that a process which need access to a
1854- shared resource created elsewhere can inherit it from an ancestor process.
1958+プロセスを強制終了させることを避ける
18551959
1856-Avoid terminating processes
1960+ あるプロセスを停止するために :meth:`Process.terminate` メソッドを使用すると、
1961+ そのプロセスが現在使用されている(ロック、セマフォ、パイプやキューのような)共有リソースを
1962+ 破壊したり他のプロセスから利用できない状態を引き起こし易いです。
18571963
1858- Using the :meth:`Process.terminate` method to stop a process is liable to
1859- cause any shared resources (such as locks, semaphores, pipes and queues)
1860- currently being used by the process to become broken or unavailable to other
1861- processes.
1964+ そのため、共有リソースを使用しないプロセスでのみ :meth:`Process.terminate` を
1965+ 使用するように考慮することがおそらく最善の方法です。
18621966
1863- Therefore it is probably best to only consider using
1864- :meth:`Process.terminate` on processes which never use any shared resources.
1967+キューを使用するプロセスを join する
18651968
1866-Joining processes that use queues
1969+ キューに要素を追加するプロセスは、全てのバッファされた要素が "feeder" スレッドによって
1970+ 下位層のパイプに対してフィードされるまで終了を待つということを覚えておいてください。
1971+ (子プロセスはこの動作を避けるためにキューの :meth:`Queue.cancel_join_thread`
1972+ メソッドを呼ぶことができます。)
18671973
1868- Bear in mind that a process that has put items in a queue will wait before
1869- terminating until all the buffered items are fed by the "feeder" thread to
1870- the underlying pipe. (The child process can call the
1871- :meth:`Queue.cancel_join_thread` method of the queue to avoid this behaviour.)
1974+ これはキューを使用するときに、キューに追加された全ての要素が最終的に
1975+ そのプロセスが join される前に削除されていることを確認する必要があることを意味します。
1976+ そうしないと、そのキューに要素が追加したプロセスの終了を保証できません。
1977+ デーモンではないプロセスは自動的に join されることも覚えておいてください。
18721978
1873- This means that whenever you use a queue you need to make sure that all
1874- items which have been put on the queue will eventually be removed before the
1875- process is joined. Otherwise you cannot be sure that processes which have
1876- put items on the queue will terminate. Remember also that non-daemonic
1877- processes will be automatically be joined.
1979+ 次の例はデッドロックを引き起こします。
18781980
1879- An example which will deadlock is the following::
1981+ ::
18801982
18811983 from multiprocessing import Process, Queue
18821984
@@ -1887,26 +1989,26 @@
18871989 queue = Queue()
18881990 p = Process(target=f, args=(queue,))
18891991 p.start()
1890- p.join() # this deadlocks
1992+ p.join() # これはデッドロックします
18911993 obj = queue.get()
18921994
1893- A fix here would be to swap the last two lines round (or simply remove the
1894- ``p.join()`` line).
1995+ 修正するには最後の2行を入れ替えます(または単純に ``p.join()`` の行を削除します)。
18951996
1896-Explicitly pass resources to child processes
1997+明示的に子プロセスへリソースを渡す
18971998
1898- On Unix a child process can make use of a shared resource created in a
1899- parent process using a global resource. However, it is better to pass the
1900- object as an argument to the constructor for the child process.
1999+ Unix 上では子プロセスはグローバルなリソースを使用する親プロセスが作成した
2000+ 共有リソースを使用することができます。しかし、引数としてそのオブジェクトを
2001+ 子プロセスのコンストラクタへ渡す方が良いです。
19012002
1902- Apart from making the code (potentially) compatible with Windows this also
1903- ensures that as long as the child process is still alive the object will not
1904- be garbage collected in the parent process. This might be important if some
1905- resource is freed when the object is garbage collected in the parent
1906- process.
2003+ (潜在的に) Windows 互換なコードを作成することは別として、さらにこれは
2004+ 子プロセスが生き続ける限り、そのオブジェクトは親プロセスでガベージコレクト
2005+ されないことも保証します。これは親プロセスでそのオブジェクトがガベージコレクト
2006+ されるときにリソースが開放される場合に重要になるでしょう。
19072007
1908- So for instance ::
2008+ そのため、例えば、
19092009
2010+ ::
2011+
19102012 from multiprocessing import Process, Lock
19112013
19122014 def f():
@@ -1917,8 +2019,10 @@
19172019 for i in range(10):
19182020 Process(target=f).start()
19192021
1920- should be rewritten as ::
2022+ 次のように書き直すべきです。
19212023
2024+ ::
2025+
19222026 from multiprocessing import Process, Lock
19232027
19242028 def f(l):
@@ -1933,36 +2037,34 @@
19332037 Windows
19342038 ~~~~~~~
19352039
1936-Since Windows lacks :func:`os.fork` it has a few extra restrictions:
2040+Windows では :func:`os.fork` がないので幾つか追加制限があります。
19372041
1938-More picklability
2042+さらなる pickle 機能
19392043
1940- Ensure that all arguments to :meth:`Process.__init__` are picklable. This
1941- means, in particular, that bound or unbound methods cannot be used directly
1942- as the ``target`` argument on Windows --- just define a function and use
1943- that instead.
2044+ :meth:`Process.__init__` へ渡す全ての引数は pickle 化できることを保証します。
2045+ これは特に束縛、又は非束縛メソッドが Windows 上の ``target`` 引数として
2046+ 直接的に使用できないことを意味します。その代わり、まさに関数を定義してください。
19442047
1945- Also, if you subclass :class:`Process` then make sure that instances will be
1946- picklable when the :meth:`Process.start` method is called.
2048+ また :class:`Process` をサブクラス化する場合、そのインスタンスが
2049+ :meth:`Process.start` メソッドが呼ばれたときに pickle 化できることを保証します。
19472050
1948-Global variables
2051+グローバル変数
19492052
1950- Bear in mind that if code run in a child process tries to access a global
1951- variable, then the value it sees (if any) may not be the same as the value
1952- in the parent process at the time that :meth:`Process.start` was called.
2053+ 子プロセスで実行されるコードがグローバル変数にアクセスしようとする場合、
2054+ 子プロセスが見るその値は :meth:`Process.start` が呼ばれたときの親プロセスの
2055+ その値と同じではない可能性があります。
19532056
1954- However, global variables which are just module level constants cause no
1955- problems.
2057+ しかし、単にモジュールレベルの定数であるグローバル変数なら問題にはなりません。
19562058
1957-Safe importing of main module
2059+メインモジュールの安全なインポート
19582060
1959- Make sure that the main module can be safely imported by a new Python
1960- interpreter without causing unintended side effects (such a starting a new
1961- process).
2061+ 新たに Python インタプリタによって、意図しない副作用(新たなプロセスを開始する等)
2062+ を起こさずにメインモジュールを安全にインポートできることを保証します。
19622063
1963- For example, under Windows running the following module would fail with a
1964- :exc:`RuntimeError`::
2064+ 例えば Windows で次のモジュールを実行しようとすると :exc:`RuntimeError` で失敗します。
19652065
2066+ ::
2067+
19662068 from multiprocessing import Process
19672069
19682070 def foo():
@@ -1971,9 +2073,11 @@
19712073 p = Process(target=foo)
19722074 p.start()
19732075
1974- Instead one should protect the "entry point" of the program by using ``if
1975- __name__ == '__main__':`` as follows::
2076+ 代わりに、次のように ``if __name__ == '__main__':`` を使用して
2077+ プログラムの "エントリポイント" を保護すべきです。
19762078
2079+ ::
2080+
19772081 from multiprocessing import Process, freeze_support
19782082
19792083 def foo():
@@ -1984,57 +2088,53 @@
19842088 p = Process(target=foo)
19852089 p.start()
19862090
1987- (The ``freeze_support()`` line can be omitted if the program will be run
1988- normally instead of frozen.)
2091+ ( ``freeze_support()`` 行はプログラムが固まらずに実行されるなら通常は取り除かれます。)
19892092
1990- This allows the newly spawned Python interpreter to safely import the module
1991- and then run the module's ``foo()`` function.
2093+ これは新たに生成された Python インタプリタがそのモジュールを安全にインポートして、
2094+ モジュールの ``foo()`` 関数を実行します。
19922095
1993- Similar restrictions apply if a pool or manager is created in the main
1994- module.
2096+ プール又はマネージャがメインモジュールで作成される場合に似たような制限が適用されます。
19952097
1996-
19972098 .. _multiprocessing-examples:
19982099
1999-Examples
2000---------
2100+例
2101+--
20012102
2002-Demonstration of how to create and use customized managers and proxies:
2103+カスタマイズされたマネージャやプロキシの作成方法と使用方法を紹介します。
20032104
20042105 .. literalinclude:: ../includes/mp_newtype.py
20052106
20062107
2007-Using :class:`Pool`:
2108+:class:`Pool` の使用例を紹介します。
20082109
20092110 .. literalinclude:: ../includes/mp_pool.py
20102111
20112112
2012-Synchronization types like locks, conditions and queues:
2113+ロック、コンディションやキューのような同期の例を紹介します
20132114
20142115 .. literalinclude:: ../includes/mp_synchronize.py
20152116
20162117
2017-An showing how to use queues to feed tasks to a collection of worker process and
2018-collect the results:
2118+ワーカープロセスのコレクションに対するタスクをフィードするキューの使用方法と
2119+その結果をまとめる方法を紹介します。
20192120
20202121 .. literalinclude:: ../includes/mp_workers.py
20212122
20222123
2023-An example of how a pool of worker processes can each run a
2024-:class:`SimpleHTTPServer.HttpServer` instance while sharing a single listening
2025-socket.
2124+ワーカープロセスのプールが1つのソケットを共有して
2125+それぞれの :class:`SimpleHTTPServer.HttpServer` インスタンスを
2126+実行する方法の例を紹介します。
20262127
20272128 .. literalinclude:: ../includes/mp_webserver.py
20282129
20292130
2030-Some simple benchmarks comparing :mod:`multiprocessing` with :mod:`threading`:
2131+:mod:`multiprocessing` と :mod:`threading` を比較した簡単なベンチマークです。
20312132
20322133 .. literalinclude:: ../includes/mp_benchmarks.py
20332134
2034-An example/demo of how to use the :class:`managers.SyncManager`, :class:`Process`
2035-and others to build a system which can distribute processes and work via a
2036-distributed queue to a "cluster" of machines on a network, accessible via SSH.
2037-You will need to have private key authentication for all hosts configured for
2038-this to work.
2135+プロセスを分散して、SSH 経由でアクセスできるネットワーク上のマシンの "クラスタ" に
2136+対する分散キューを経由するシステム上で構築された :class:`managers.SyncManager`,
2137+:class:`Process` やその他の使用方法の例/デモです。
2138+この処理を実行するために全てのホストで秘密鍵認証を行う必要があります。
20392139
20402140 .. literalinclude:: ../includes/mp_distributing.py
Afficher sur ancien navigateur de dépôt.