Optimzing multiprocessing.Pool z drogich inicjalizacji

Question

Powyżej znajduje się pełna prosty przykład działa

import multiprocessing as mp 
import time 
import random 


class Foo: 
    def __init__(self): 
     # some expensive set up function in the real code 
     self.x = 2 
     print('initializing') 

    def run(self, y): 
     time.sleep(random.random()/10.) 
     return self.x + y 


def f(y): 
    foo = Foo() 
    return foo.run(y) 


def main(): 
    pool = mp.Pool(4) 
    for result in pool.map(f, range(10)): 
     print(result) 
    pool.close() 
    pool.join() 


if __name__ == '__main__': 
    main() 

Jak mogę go zmodyfikować tak Foo jest inicjowana tylko raz przez każdego pracownika, nie każde zadanie? Zasadniczo chcę init nazywa się 4 razy, a nie 10. Używam Python 3.5

Answer 1

Zamierzony sposób na radzenie sobie z rzeczy, jak to odbywa się za pomocą opcjonalnych initializer i initargs argumentów do konstruktora Pool(). Istnieją one dokładnie po to, aby dać ci sposób na zrobienie rzeczy dokładnie raz, gdy tworzony jest proces roboczy. Tak więc, na przykład, dodać:

def init(): 
    global foo 
    foo = Foo() 

i zmienić tworzenie Pool do:

pool = mp.Pool(4, initializer=init) 

Jeśli potrzebne do przekazywania argumentów do funkcji każdego procesu inicjalizacji, to by też dodać odpowiedni initargs=... argument.

Uwaga: Oczywiście należy również usunąć wiersz

foo = Foo() 

od f(), tak że funkcja wykorzystuje globalny foo stworzony przez init().

Answer 2

najbardziej oczywistą, leniwy obciążenia

_foo = None 
def f(y): 
    global _foo 
    if not _foo: 
     _foo = Foo() 
    return _foo.run(y)