Il modulo multiprocessing in python

Il modulo multiprocessing del linguaggio python mi permette di lanciare dei processi da un programma e parallelizzare l'elaborazione dei dati.

import multiprocessing

Qual è la differenza tra multiprocessing e threading?

Il modulo threading crea dei sottoprocessi ( thread ) mentre il modulo multiprocessing genera dei veri e propri processi indipendenti dal programma.

Un esempio pratico

Per prima cosa importo il modulo multiprocessing in python.

import multiprocessing as mp

Importo anche la libreria os per usare la funzione getpid().

Mi servirà per vedere il numero identificativo del processo ( pid ).

import os

Poi definisco una funzione che stampa un messaggio, un argomento e il numero del processo.

def hello(n):
print("[{0}] Hello! pid= {1} ".format(n,os.getpid()))

A questo punto devo sviluppare la parte del codice per lanciare i processi.

Questa parte del programma deve essere eseguita soltanto dal processo principale ( __main__ ).

if __name__ == '__main__':
print(" inizio ")
t = mp.Process(target=hello, args=(1,))
t.start()
t = mp.Process(target=hello, args=(2,))
t.start()
t = mp.Process(target=hello, args=(3,))
t.start()
print(" fine ")

Il programma stampa la stringa "inizio".

Poi lancia come processo la funzione hello per tre volte, passando ogni volta un parametro diverso (1,2,3).

Infine stampa la stringa "fine".

A questo punto devo soltanto lanciare il programma.

Attenzione. Il modulo multiprocessing non funziona con l'editor IDLE. Per vedere gli effetti devo lanciare il programma python direttamente dalla riga comando del sistema operativo.

L'output del programma è il seguente:

inizio
fine
[1] Hello! pid= 12100
[3] Hello! pid= 11796
[2] Hello! pid= 15620

Spiegazione

Il programma principale lancia i tre processi e termina l'elaborazione.

Come si può notare, le prime stringhe a essere visualizzate sono "inizio" e "fine".

inizio
fine

Subito dopo si concludono anche i processi.

Tra parentesi quadre è visualizzato il parametro passato alla funzione durante la chiamata.

[1] Hello! pid= 12100
[3] Hello! pid= 11796
[2] Hello! pid= 15620

Come si può notare l'output non segue esattamente l'ordine sequenziale di chiamata dei processi [1], [2], [3].

In questo caso, pur essendo stato lanciato per ultimo, il terzo processo [3] termina prima del secondo processo [2].

Questo accade perché l'elaborazione non segue l'ordine della chiamata della funzione, bensì quella di elaborazione del processo da parte della CPU e del sistema operativo del computer.

Inoltre, i tre processi hanno un numero pid diverso.

Nota. Nel caso del threading avrebbero invece avuto lo stesso numero pid.

Il metodo join

Come nel threading anche il multiprocessing permette l'utilizzo del metodo join.

A cosa serve?

Il metodo join mi permette di bloccare l'esecuzione del programma principale fin quando i processi o un processo in particolare terminano l'esecuzione.

Esempio

Riprendo l'esempio precedente modificando la funzione hello.

In questo caso il programma lancia 5 processi e ogni volta che lancia un processo lo aggiunge alla lista processi[].

processi = [ ]
if __name__ == '__main__':
print(" inizio ")
for i in range(5):
t = mp.Process(target=hello, args=(i,))
t.start()
processi.append(t)
for p in processi:
p.join()
print(" fine ")

Dopo averli lanciati tutti, il programma legge i processi dalla lista per verificare se sono finiti oppure no con il metodo join().

• Se un processo è terminato, il programma passa a controllare l'elemento successivo della lista
• Se un processo non è ancora finito, il programma aspetta la fine del processo.

Soltanto dopo aver appurato che tutti sono finiti, il programma stampa la stringa "fine".

L'output è il seguente:

inizio
[1] Hello! pid= 16496
[2] Hello! pid= 16624
[0] Hello! pid= 9620
[4] Hello! pid= 12788
[3] Hello! pid= 5788
fine

Anche in questo caso l'ordine di esecuzione dei processi non segue l'ordine di chiamata e ogni processo ha un numero pid diverso.

Questa volta però la stringa "fine" è stampata per ultima perché il programma principale è l'ultimo a terminare l'esecuzione.

E così via.