Birden çok işleme tabi tutulan bir işlevin dönüş değerini nasıl kurtarabilirim?

Aşağıdaki örnek kodda, işlevin dönüş değerini kurtarmak istiyorum worker. Bunu nasıl yapabilirim? Bu değer nerede saklanır?

Örnek Kod:

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

Çıktı:

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

Depolanan nesnelerde ilgili özniteliği bulamıyorum jobs.

İletişim kurmak için paylaşılan değişkeni kullanın . Örneğin şöyle:

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

@Sega_sai tarafından önerilen yaklaşım daha iyi olduğunu düşünüyorum. Ama gerçekten bir kod örneği gerekiyor, işte gidiyor:

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

Hangi dönüş değerleri yazdırılacaktır:

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 yerleşik) hakkında bilginiz varsa, bu çok zor olmamalıdır. Aksi takdirde sega_Sai'nin bağlantısına bir göz atın .

Ne kadar az kod gerektiğini unutmayın. (İşlemlerin nasıl yeniden kullanıldığını da unutmayın).

Bu örnek, çok işlemli bir listenin nasıl kullanılacağını gösterir. Rasgele sayıda işlemden dizeleri döndürmek için boru örnekleri:

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

Çıktı:

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

Bu çözüm, çok işlemciliğe göre daha az kaynak kullanır.

• bir boru
• en az bir Kilit
• Bir tampon
• bir iplik

veya multiprocessing.SimpleQueue olan kullanımları

• bir boru
• en az bir Kilit

Bu türlerin her birinin kaynağına bakmak çok öğreticidir.

Bazı nedenlerden dolayı, bunun Queueherhangi bir yerde nasıl yapılacağına dair genel bir örnek bulamadım (Python'un doktor örnekleri bile birden fazla işlem üretmiyor), bu yüzden 10 denemeden sonra çalıştığım şey:

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

Queuealt işlemlerden döndürülen değerleri depolamak için kullanabileceğiniz engelleme, iş parçacığı açısından güvenli bir kuyruktur. Bu yüzden kuyruğu her bir işleme geçirmek zorundasınız. Burada az belirgin şey yapmak zorunda olduğunu get()senden önce kuyruktan es ya da başka kuyruk doldurur ve bloklar her şeyi.joinProcess

Nesneye yönelik olanlar için güncelleme (Python 3.4'te test edilmiştir):

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)

Bir kullanımdan nasıl değer elde edeceğini arayan herkes Processiçin 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()

Bunun yerine multiprocessing.Pool sınıfını kullanmanız ve .apply () .apply_async (), map () yöntemlerini kullanmanız gerektiği görülmektedir.

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

exitBir işlemin çıkış kodunu ayarlamak için yerleşik olanı kullanabilirsiniz. exitcodeSürecin özelliğinden elde edilebilir :

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

Çıktı:

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

Çakıl paketi güzel bir soyutlama yararlanarak sahip multiprocessing.Pipebu oldukça basit hale getirir:

from pebble import concurrent

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

future = function(1, kwarg=1)

print(future.result())

Örnek: https://pythonhosted.org/Pebble/#concurrent-decorators

Py3.6'da benim için çalışarak yukarıdan kopyalanan en basit örnekleri basitleştireceğimi düşündüm. En basit olanı multiprocessing.Pool:

import multiprocessing
import time

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

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

Havuzdaki işlem sayısını, örn Pool(processes=5). Ancak varsayılan olarak CPU sayımına sahiptir, bu nedenle CPU'ya bağlı görevler için boş bırakın. (G / Ç-bağlı görevler genellikle iş parçacıkları genellikle bekler, çünkü iş parçacıkları çoğunlukla bir CPU çekirdeğini paylaşabilir.) PoolAyrıca parçalama optimizasyonu uygular .

(Worker yöntemi bir yöntem içinde yuvalanamaz unutmayın. Ben başlangıçta benim yöntem pool.maptüm kendi kendine yeten tutmak için , çağrı yapan yöntem içinde tanımladı , ancak sonra süreçler onu alamadım ve attı "AttributeError : External_method..inner_method yerel nesnesi seçilemiyor. "Daha fazla burada . Bir sınıfın içinde olabilir.)

(Baskı 'represent!'yerine belirtilen orijinal soruyu takdir edin time.sleep(), ancak onsuz bazı kodların aynı anda çalıştığını düşündüm.)

Py3'ler ProcessPoolExecutorde iki satırdır ( .mapbir jeneratör döndürür, böylece ihtiyacınız olur list()):

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

Düz Processes ile:

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

SimpleQueueİhtiyacınız olan tek şey putve ise kullanın get. İlk döngü engelleme queue.getçağrıları yapmadan önce tüm işlemleri başlatır . Aramak için p.join()de bir sebep olduğunu sanmıyorum .

Basit bir çözüm:

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

Çıktı:

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

Python 3 kullanıyorsanız, concurrent.futures.ProcessPoolExecutoruygun bir soyutlama olarak kullanabilirsiniz :

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

Çıktı:

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

Ben fonksiyondan hata kodları almak gerektiğinden vartec cevap biraz değiştirdim. (Teşekkürler vertec !!! harika bir numara)

Bu bir ile de yapılabilir, manager.listancak bir dikte içinde olması ve içindeki bir listeyi saklamak daha iyidir. Bu şekilde, listenin yerleştirileceği sıradan emin olamadığımız için işlevi ve sonuçları tutarız.

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