Wie kann ich den Rückgabewert einer an multiprocessing.Process übergebenen Funktion wiederherstellen?

Im folgenden Beispielcode möchte ich den Rückgabewert der Funktion wiederherstellen worker. Wie kann ich das machen? Wo ist dieser Wert gespeichert?

Beispielcode:

import multiprocessing

def worker(procnum):
    '''worker function'''
    print str(procnum) + ' represent!'
    return procnum


if __name__ == '__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

Ausgabe:

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)>]

Ich kann das relevante Attribut in den darin gespeicherten Objekten nicht finden jobs.

Verwenden Sie eine gemeinsam genutzte Variable für die Kommunikation. Zum Beispiel so:

import multiprocessing

def worker(procnum, return_dict):
    '''worker function'''
    print str(procnum) + ' represent!'
    return_dict[procnum] = procnum


if __name__ == '__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()

Ich denke, der von @sega_sai vorgeschlagene Ansatz ist der bessere. Aber es braucht wirklich ein Codebeispiel, also geht es weiter:

import multiprocessing
from os import getpid

def worker(procnum):
    print('I am number %d in process %d' % (procnum, getpid()))
    return getpid()

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes = 3)
    print(pool.map(worker, range(5)))

Welches gibt die Rückgabewerte aus:

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]

Wenn Sie mit map(dem integrierten Python 2) vertraut sind, sollte dies nicht zu schwierig sein. Ansonsten schau dir den Link von sega_Sai an .

Beachten Sie, wie wenig Code benötigt wird. (Beachten Sie auch, wie Prozesse wiederverwendet werden).

Dieses Beispiel zeigt, wie eine Liste von Multiprocessing.Pipe- Instanzen verwendet wird, um Zeichenfolgen aus einer beliebigen Anzahl von Prozessen zurückzugeben:

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 __name__ == '__main__':
    main()

Ausgabe:

0 represent!
1 represent!
2 represent!
3 represent!
4 represent!
['0 represent!', '1 represent!', '2 represent!', '3 represent!', '4 represent!']

Diese Lösung verbraucht weniger Ressourcen als eine Multiprocessing.Queue, die verwendet wird

• ein Rohr
• mindestens ein Schloss
• ein Puffer
• ein Faden

oder eine Multiprocessing.SimpleQueue, die verwendet

• ein Rohr
• mindestens ein Schloss

Es ist sehr lehrreich, die Quelle für jeden dieser Typen zu betrachten.

Aus irgendeinem Grund konnte ich Queuenirgendwo ein allgemeines Beispiel dafür finden (selbst Pythons Dokumentbeispiele erzeugen nicht mehrere Prozesse). Nach 10 Versuchen habe ich Folgendes getan:

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

Queueist eine blockierende, threadsichere Warteschlange, in der Sie die Rückgabewerte der untergeordneten Prozesse speichern können. Sie müssen also die Warteschlange an jeden Prozess übergeben. Etwas weniger offensichtliches ist hier, dass Sie get()aus der Warteschlange müssen, bevor Sie joindie Processes oder die Warteschlange füllt und blockiert alles.

Update für objektorientierte Benutzer (getestet in 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 __name__ == "__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)

Für alle anderen, die suchen, wie sie einen Wert aus einer ProcessVerwendung ziehen können Queue:

import multiprocessing

ret = {'foo': False}

def worker(queue):
    ret = queue.get()
    ret['foo'] = True
    queue.put(ret)

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    queue.put(ret)
    p = multiprocessing.Process(target=worker, args=(queue,))
    p.start()
    print queue.get()  # Prints {"foo": True}
    p.join()

Es scheint, dass Sie stattdessen die Klasse multiprocessing.Pool verwenden und die Methoden .apply () .apply_async (), map () verwenden sollten.

http://docs.python.org/library/multiprocessing.html?highlight=pool#multiprocessing.pool.AsyncResult

Mit der integrierten Funktion können Sie exitden Exit-Code eines Prozesses festlegen. Es kann aus dem exitcodeAttribut des Prozesses erhalten werden:

import multiprocessing

def worker(procnum):
    print str(procnum) + ' represent!'
    exit(procnum)

if __name__ == '__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

Ausgabe:

0 represent!
1 represent!
2 represent!
3 represent!
4 represent!
[0, 1, 2, 3, 4]

Das Kieselpaket hat eine nette Abstraktion, multiprocessing.Pipedie dies recht einfach macht:

from pebble import concurrent

@concurrent.process
def function(arg, kwarg=0):
    return arg + kwarg

future = function(1, kwarg=1)

print(future.result())

Beispiel von: https://pythonhosted.org/Pebble/#concurrent-decorators

Ich dachte, ich würde die einfachsten Beispiele, die von oben kopiert wurden, vereinfachen und für mich an Py3.6 arbeiten. Am einfachsten ist multiprocessing.Pool:

import multiprocessing
import time

def worker(x):
    time.sleep(1)
    return x

pool = multiprocessing.Pool()
print(pool.map(worker, range(10)))

Sie können die Anzahl der Prozesse im Pool festlegen, z Pool(processes=5). Standardmäßig wird jedoch die CPU-Anzahl verwendet. Lassen Sie diese Option daher für CPU-gebundene Aufgaben leer. (E / A-gebundene Aufgaben passen ohnehin oft zu Threads, da die Threads meistens warten und einen CPU-Kern gemeinsam nutzen können.) WendetPool auch die Chunking-Optimierung an .

(Beachten Sie, dass die Worker-Methode nicht in einer Methode verschachtelt werden kann. Ich habe meine Worker-Methode zunächst in der Methode definiert, die aufgerufen pool.mapwird, um alles in sich geschlossen zu halten, aber dann konnten die Prozesse sie nicht importieren und haben "AttributeError" ausgelöst : Lokales Objekt Outer_Method..inner_method kann nicht ausgewählt werden. Mehr hier . Es kann sich innerhalb einer Klasse befinden.)

(Schätzen Sie den Druck der ursprünglichen Frage 'represent!' und nicht time.sleep(), aber ohne sie dachte ich, dass ein Code gleichzeitig ausgeführt wird, wenn dies nicht der Fall ist.)

Py3 ProcessPoolExecutorist auch zwei Zeilen ( .mapgibt einen Generator zurück, so dass Sie die benötigenlist() ):

from concurrent.futures import ProcessPoolExecutor
with ProcessPoolExecutor() as executor:
    print(list(executor.map(worker, range(10))))

Mit schlicht Process es:

import multiprocessing
import time

def worker(x, queue):
    time.sleep(1)
    queue.put(x)

queue = multiprocessing.SimpleQueue()
tasks = range(10)

for task in tasks:
    multiprocessing.Process(target=worker, args=(task, queue,)).start()

for _ in tasks:
    print(queue.get())

Verwenden Sie, SimpleQueuewenn Sie nur putund benötigen get. Die erste Schleife startet alle Prozesse, bevor die zweite die blockierenden queue.getAufrufe ausführt . Ich glaube nicht, dass es einen Grund gibt, auch anzurufen p.join().

Eine einfache Lösung:

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 __name__ == '__main__':
    output.append(handler())

print(output[0])

Ausgabe:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Wenn Sie Python 3 verwenden, können Sie Folgendes verwenden concurrent.futures.ProcessPoolExecutor:

from concurrent.futures import ProcessPoolExecutor

def worker(procnum):
    '''worker function'''
    print(str(procnum) + ' represent!')
    return procnum


if __name__ == '__main__':
    with ProcessPoolExecutor() as executor:
        print(list(executor.map(worker, range(5))))

Ausgabe:

0 represent!
1 represent!
2 represent!
3 represent!
4 represent!
[0, 1, 2, 3, 4]

Ich habe die Antwort von vartec ein wenig geändert, da ich die Fehlercodes von der Funktion erhalten musste. (Danke vertec !!! es ist ein toller Trick)

Dies kann auch mit einem gemacht werden, manager.listaber ich denke, es ist besser, es in einem Diktat zu haben und eine Liste darin zu speichern. Auf diese Weise behalten wir die Funktion und die Ergebnisse bei, da wir nicht sicher sind, in welcher Reihenfolge die Liste gefüllt wird.

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 __name__ == '__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