Eseguire un'elaborazione parallela in Python

1. Usa il pool di elaborazione e i suoi metodi per eseguire multiprocessing in Python
2. Usa la funzione apply_async() per eseguire multiprocessing in Python
3. Usa le funzioni map() e map_sync() per eseguire multiprocessing in Python

Questo articolo spiega come eseguire più processi in parallelo in Python.

Usa il pool di elaborazione e i suoi metodi per eseguire multiprocessing in Python

Per eseguire il multiprocessing in Python, procedi come segue.

• Per prima cosa, importa il modulo multiprocessing.
• Usare la classe Pool per definire il Python Processing Pool. Questo Pool rappresenta un pool di processi di lavoro. Prendi il frammento di codice qui sotto come esempio.

Pool(processes=n)

Di conseguenza, la classe Pool consentirà l’esecuzione simultanea del numero n di processi. Questa classe contiene metodi che abilitano la delega di attività ai processi di lavoro del Pool.

I seguenti sono alcuni dei metodi della classe Pool.

• Pool.map() - Usa questo metodo di blocco del Pool per bloccare fino a quando il risultato non è pronto. Questo metodo taglia l’iterabile associato in diversi blocchi. Quindi, invia i blocchi al pool di processi come attività separate.

• Utilizzare i seguenti metodi non bloccanti della classe Pool per inviare i processi contemporaneamente contemporaneamente. Utilizzare il metodo get() per ottenere i risultati della funzione.

• Pool.apply_async()

• Pool.map_async()

Per determinare il numero di processi che la tua macchina può gestire per il multiprocessing, dovresti conoscere il numero di processori che hai nel tuo dispositivo; puoi verificarlo utilizzando il seguente codice.

import multiprocessing as mp

print("Number of processors: ", mp.cpu_count())

Produzione:

Number of processors:  4

Usa la funzione apply_async() per eseguire multiprocessing in Python

Ecco un esempio che dimostra il multiprocessing utilizzando il pool di elaborazione in Python mentre si determina il quadrato di un intervallo sui numeri da 0-9.

Nota che qui abbiamo persino stampato il nome dell’operatore del processo, che è facoltativo.

from multiprocessing import Pool
from multiprocessing import Process, current_process
import time
from time import sleep
import random


def fnc_square(x):
    print(current_process().name)
    return x * x


if __name__ == "__main__":
    pool = Pool(processes=4)
    result = pool.apply_async(fnc_square, [6])
    print(result.get(timeout=1))
    print(pool.map(fnc_square, range(10)))

Produzione:

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

Usa le funzioni map() e map_sync() per eseguire multiprocessing in Python

La funzione map_async è non bloccante, mentre la funzione map è bloccante. Di seguito è riportato un esempio che dimostra la differenza tra questi due comandi.

from multiprocessing import Pool
import time


def f(x):
    print(x * x)


if __name__ == "__main__":
    pool = Pool(processes=1)
    pool.map(f, range(10))
    r = pool.map_async(f, range(10))
    print("First print")
    print("Second print")
    r.wait()
    print("Third print")

Qui possiamo osservare che la funzione pool.map() attenderà il completamento delle 10 chiamate di operazione. Quindi, vediamo il risultato stampato in ordine.

Inoltre, pool.map_async() eseguirà le 10 chiamate di funzione in modo asincrono. Quando viene chiamata la funzione r.wait(), blocca il processore per l’esecuzione. Quindi, nell’output, vediamo i messaggi di stampa come First print e Second print in mezzo, ma la Third print sarà sempre alla fine.

Produzione:

0
1
4
9
16
25
36
49
64
81
First print
Second print
0
1
4
9
16
25
36
49
64
81
Third print