2011-08-07 24 views
10

La mayoría de los ejemplos de grupos de trabajadores multiproceso ejecutan una única función en diferentes procesos, es decir,Mulitprocess Grupos con funciones diferentes

def foo(args): 
    pass 

if __name__ == '__main__': 
    pool = multiprocessing.Pool(processes=30) 
    res=pool.map_async(foo,args) 

¿Hay alguna manera de manejar dos funciones diferentes e independientes dentro de la agrupación? Para que pueda asignar f.e. 15 procesos para foo() y 15 procesos para bar() o es un grupo limitado a una sola función? O du hay que crear diferentes procesos para diferentes funciones de forma manual con

p = Process(target=foo, args=(whatever,)) 
q = Process(target=bar, args=(whatever,)) 
q.start() 
p.start() 

y olvidarse de la piscina de los trabajadores?

Respuesta

14

Para pasar diferentes funciones, simplemente puede llamar al map_async varias veces.

Aquí se muestra un ejemplo para ilustrar que,

from multiprocessing import Pool 
from time import sleep 

def square(x): 
    return x * x 

def cube(y): 
    return y * y * y 

pool = Pool(processes=20) 

result_squares = pool.map_async(f, range(10)) 
result_cubes = pool.map_async(g, range(10)) 

El resultado será:

>>> print result_squares.get(timeout=1) 
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 

>>> print result_cubes.get(timeout=1) 
[0, 1, 8, 27, 64, 125, 216, 343, 512, 729] 
+0

Y van a ser ejecutado en paralelo o "en fila"? – dorvak

+2

El 'map_async' regresa inmediatamente. Siempre que haya suficientes procesos libres en el grupo, se ejecutarán nuevas tareas sin tener que esperar. En el ejemplo anterior, se ejecutarán en paralelo. @mad_scientist –

+1

¡Pero no hay manera de asignar una cantidad específica de trabajadores/procesos, supongo? – dorvak

1

Lo harán no de ejecución en paralelo. Ver siguiente código:

def updater1(q,i):  
    print "UPDATER 1:", i 
    return 

def updater2(q,i):  
    print "UPDATER2:", i 
    return 

if __name__=='__main__': 
    a = range(10) 
    b=["abc","def","ghi","jkl","mno","pqr","vas","dqfq","grea","qfwqa","qwfsa","qdqs"] 


    pool = multiprocessing.Pool() 

    func1 = partial(updater1,q) 
    func2 = partial(updater2,q) 
    pool.map_async(func1, a) 
    pool.map_async(func2, b) 

    pool.close() 
    pool.join() 

El código anterior produce la siguiente impresión:

UPDATER 1: 1 
UPDATER 1: 0 
UPDATER 1: 2 
UPDATER 1: 3 
UPDATER 1: 4 
UPDATER 1: 5 
UPDATER 1: 6 
UPDATER 1: 7 
UPDATER 1: 8 
UPDATER 1: 9 
UPDATER2: abc 
UPDATER2: def 
UPDATER2: ghi 
UPDATER2: jkl 
UPDATER2: mno 
UPDATER2: pqr 
UPDATER2: vas 
UPDATER2: dqfq 
UPDATER2: grea 
UPDATER2: qfwqa 
UPDATER2: qwfsa 
UPDATER2: qdqs 
Cuestiones relacionadas