multiprocessing.Processに渡された関数の戻り値を回復するにはどうすればよいですか？
以下のサンプルコードでは、関数workerの戻り値を回復したいと思います。どうすればこれを行うことができますか？この値はどこに保存されますか？
サンプルコード：
import multiprocessing
def worker(procnum):
'''worker function'''
print str(procnum) + ' represent!'
return procnum
if __== '__main__':
jobs = []
for i in range(5):
p = multiprocessing.Process(target=worker, args=(i,))
jobs.append(p)
p.start()
for proc in jobs:
proc.join()
print jobs
出力：
0 represent!
1 represent!
2 represent!
3 represent!
4 represent!
[<Process(Process-1, stopped)>, <Process(Process-2, stopped)>, <Process(Process-3, stopped)>, <Process(Process-4, stopped)>, <Process(Process-5, stopped)>]
jobsに格納されているオブジェクトに関連する属性が見つからないようです。
共有変数 を使用して通信します。たとえば、次のようなものです。
import multiprocessing
def worker(procnum, return_dict):
'''worker function'''
print str(procnum) + ' represent!'
return_dict[procnum] = procnum
if __== '__main__':
manager = multiprocessing.Manager()
return_dict = manager.dict()
jobs = []
for i in range(5):
p = multiprocessing.Process(target=worker, args=(i,return_dict))
jobs.append(p)
p.start()
for proc in jobs:
proc.join()
print return_dict.values()
@sega_saiが提案するアプローチの方が優れていると思います。しかし、実際にはコード例が必要なので、ここに行きます：
import multiprocessing
from os import getpid
def worker(procnum):
print 'I am number %d in process %d' % (procnum, getpid())
return getpid()
if __== '__main__':
pool = multiprocessing.Pool(processes = 3)
print pool.map(worker, range(5))
戻り値を出力します：
I am number 0 in process 19139
I am number 1 in process 19138
I am number 2 in process 19140
I am number 3 in process 19139
I am number 4 in process 19140
[19139, 19138, 19140, 19139, 19140]
map（Python 2ビルトイン）に精通している場合、これはそれほど難しくないはずです。それ以外の場合は、 sega_Saiのリンク をご覧ください。
コードがほとんど必要ないことに注意してください。 （プロセスの再利用方法にも注意してください）。
この例は、 multiprocessing.Pipe インスタンスのリストを使用して、任意の数のプロセスから文字列を返す方法を示しています。
import multiprocessing
def worker(procnum, send_end):
'''worker function'''
result = str(procnum) + ' represent!'
print result
send_end.send(result)
def main():
jobs = []
pipe_list = []
for i in range(5):
recv_end, send_end = multiprocessing.Pipe(False)
p = multiprocessing.Process(target=worker, args=(i, send_end))
jobs.append(p)
pipe_list.append(recv_end)
p.start()
for proc in jobs:
proc.join()
result_list = [x.recv() for x in pipe_list]
print result_list
if __== '__main__':
main()
出力：
0 represent!
1 represent!
2 represent!
3 represent!
4 represent!
['0 represent!', '1 represent!', '2 represent!', '3 represent!', '4 represent!']
このソリューションは、 multiprocessing.Queue よりも少ないリソースを使用します
- パイプ
- 少なくとも1つのロック
- バッファ
- スレッド
または multiprocessing.SimpleQueue を使用します
- パイプ
- 少なくとも1つのロック
これらの各タイプのソースを調べることは非常に有益です。
Processを使用してQueueから値を取得する方法を探している他のユーザーの場合：
import multiprocessing
ret = {'foo': False}
def worker(queue):
ret = queue.get()
ret['foo'] = True
queue.put(ret)
if __== '__main__':
queue = multiprocessing.Queue()
queue.put(ret)
p = multiprocessing.Process(target=worker, args=(queue,))
p.start()
print queue.get() # Prints {"foo": True}
p.join()
代わりに multiprocessing.Pool クラスを使用し、メソッド.apply（）.apply_async（）、map（）を使用する必要があるようです
http://docs.python.org/library/multiprocessing.html?highlight=pool#multiprocessing.pool.AsyncResult
何らかの理由で、Queueを使用してこれを行う方法の一般的な例はどこにも見つかりませんでした（Pythonのdocの例でも複数のプロセスは生成されません）。
def add_helper(queue, arg1, arg2): # the func called in child processes
ret = arg1 + arg2
queue.put(ret)
def multi_add(): # spawns child processes
q = Queue()
processes = []
rets = []
for _ in range(0, 100):
p = Process(target=add_helper, args=(q, 1, 2))
processes.append(p)
p.start()
for p in processes:
ret = q.get() # will block
rets.append(ret)
for p in processes:
p.join()
return rets
Queueは、子プロセスからの戻り値を格納するために使用できる、スレッドセーフブロッキングキューです。そのため、各プロセスにキューを渡す必要があります。ここであまり明らかではないことは、joinをProcessesに入れる前に、キューからget()する必要があることです。
更新オブジェクト指向の人（Python 3.4でテスト済み）：
from multiprocessing import Process, Queue
class Multiprocessor():
def __init__(self):
self.processes = []
self.queue = Queue()
@staticmethod
def _wrapper(func, queue, args, kwargs):
ret = func(*args, **kwargs)
queue.put(ret)
def run(self, func, *args, **kwargs):
args2 = [func, self.queue, args, kwargs]
p = Process(target=self._wrapper, args=args2)
self.processes.append(p)
p.start()
def wait(self):
rets = []
for p in self.processes:
ret = self.queue.get()
rets.append(ret)
for p in self.processes:
p.join()
return rets
# tester
if __== "__main__":
mp = Multiprocessor()
num_proc = 64
for _ in range(num_proc): # queue up multiple tasks running `sum`
mp.run(sum, [1, 2, 3, 4, 5])
ret = mp.wait() # get all results
print(ret)
assert len(ret) == num_proc and all(r == 15 for r in ret)
exitビルトインを使用して、プロセスの終了コードを設定できます。プロセスのexitcode属性から取得できます。
import multiprocessing
def worker(procnum):
print str(procnum) + ' represent!'
exit(procnum)
if __== '__main__':
jobs = []
for i in range(5):
p = multiprocessing.Process(target=worker, args=(i,))
jobs.append(p)
p.start()
result = []
for proc in jobs:
proc.join()
result.append(proc.exitcode)
print result
出力：
0 represent!
1 represent!
2 represent!
3 represent!
4 represent!
[0, 1, 2, 3, 4]
pebble パッケージには、multiprocessing.Pipeを利用したニース抽象化があり、これは非常に簡単です。
from pebble import concurrent
@concurrent.process
def function(arg, kwarg=0):
return arg + kwarg
future = function(1, kwarg=1)
print(future.result())
Python 3を使用している場合は、便利な抽象化として concurrent.futures.ProcessPoolExecutor を使用できます。
from concurrent.futures import ProcessPoolExecutor
def worker(procnum):
'''worker function'''
print(str(procnum) + ' represent!')
return procnum
if __== '__main__':
with ProcessPoolExecutor() as executor:
print(list(executor.map(worker, range(5))))
出力：
0 represent!
1 represent!
2 represent!
3 represent!
4 represent!
[0, 1, 2, 3, 4]
簡単な解決策：
import multiprocessing
output=[]
data = range(0,10)
def f(x):
return x**2
def handler():
p = multiprocessing.Pool(64)
r=p.map(f, data)
return r
if __== '__main__':
output.append(handler())
print(output[0])
出力：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
関数からエラーコードを取得する必要があるため、vartecの回答を少し変更しました。 （ありがとうございました!!!その素晴らしいトリック）
これはmanager.listでも実行できますが、辞書に入れてリストを保存する方が良いと思います。そのようにして、リストにデータが入力される順序がわからないため、関数と結果を保持します。
from multiprocessing import Process
import time
import datetime
import multiprocessing
def func1(fn, m_list):
print 'func1: starting'
time.sleep(1)
m_list[fn] = "this is the first function"
print 'func1: finishing'
# return "func1" # no need for return since Multiprocess doesnt return it =(
def func2(fn, m_list):
print 'func2: starting'
time.sleep(3)
m_list[fn] = "this is function 2"
print 'func2: finishing'
# return "func2"
def func3(fn, m_list):
print 'func3: starting'
time.sleep(9)
# if fail wont join the rest because it never populate the dict
# or do a try/except to get something in return.
raise ValueError("failed here")
# if we want to get the error in the manager dict we can catch the error
try:
raise ValueError("failed here")
m_list[fn] = "this is third"
except:
m_list[fn] = "this is third and it fail horrible"
# print 'func3: finishing'
# return "func3"
def runInParallel(*fns): # * is to accept any input in list
start_time = datetime.datetime.now()
proc = []
manager = multiprocessing.Manager()
m_list = manager.dict()
for fn in fns:
# print fn
# print dir(fn)
p = Process(target=fn, name=fn.func_name, args=(fn, m_list))
p.start()
proc.append(p)
for p in proc:
p.join() # 5 is the time out
print datetime.datetime.now() - start_time
return m_list, proc
if __== '__main__':
manager, proc = runInParallel(func1, func2, func3)
# print dir(proc[0])
# print proc[0]._name
# print proc[0].name
# print proc[0].exitcode
# here you can check what did fail
for i in proc:
print i.name, i.exitcode # name was set up in the Process line 53
# here will only show the function that worked and where able to populate the
# manager dict
for i, j in manager.items():
print dir(i) # things you can do to the function
print i, j