Comparació de solucions segons model concurrent

Exemple 1

Fitxer mp1.py

from multiprocessing import Process

def doble(n):
    print('el doble de {} és {}'.format(n, n*2))

def triple(n):
    print('el triple de {} és {}'.format(n, n*3))

if __name__ == '__main__':
    procs = [Process(target=doble, args=(3,)),
             Process(target=triple, args=(4,))]
    for p in procs:
        p.start()
    for p in procs:
         p.join()

Manager

Fitxer mpManager.py

import sys
from multiprocessing import Process, Manager

def doble(dades, result):
    res=[]
    for dada in dades:
        res.append(dada*2)
    result.update({'retorn doble': res}) 

def triple(dades, result):
    res=[]
    for dada in dades:
        res.append(dada*3)
    result.update({'retorn triple': res}) 

def enParallel(dict):
    manager = Manager()
    result = manager.dict()
    proc = [] 
    for funció in dict:
        dict[funció].append(result)
        p = Process(target=funció,
                    args= tuple(dict[funció]))
        p.start()
        proc.append(p)
    for p in proc:
        p.join()
    return result
 
dict = {doble : [(n for n in range(10))],
        triple: [(n for n in range(7))]}
resultats = enParallel(dict)
print(resultats)

Pipe

Fitxer mpPipe.py

from multiprocessing import Process, Pipe

def fill(conn):
    conn.send([12, 0.5, 'un string', [1,2,3]])
    conn.close()

if __name__ == '__main__':
    connexioPare, connexioFill = Pipe()
    p = Process(target=fill, args=(connexioFill,))
    p.start()
    print(connexioPare.recv())
    p.join()

Exemple Pool

Fitxer mpPool.py

from multiprocessing import Pool

def quadrat(x):
    return x*x

if __name__ == '__main__':
    with Pool(10) as p:
        print(p.map(quadrat, [1, 2, 3, 4, 5]))

Queue

Fitxer mpQueue.py

from multiprocessing import Process, Queue, Lock

def productor(p, nElems, Cua):
    for i in range(nElems):
        Cua.put((p, i*i*i))
    Cua.close()

def consumidor(p, nElems, Cua, Pany):
    while True:
        res = Cua.get()
        with Pany:
            print(f'c{p}', res)

Cua = Queue()
Pany = Lock()
procsP=[Process(target=productor,
                args=(p, 100, Cua)) for p in range(3)]
procsC=[Process(target=consumidor,
                args=(p, 100, Cua, Pany)) for p in range(2)]
for p in procsC:
    p.daemon=True
for p in procsP+procsC:
    p.start()
for p in procsP:
    p.join()