Pool multiprocessing Python

La distribuzione di due o anche più unità di elaborazione centrale in un sistema di processore è noto come multiprocessing. La funzionalità del sistema potrebbe essere notevolmente migliorata mediante multiprocessing. Python utilizza solo un'unità di elaborazione centrale a causa di Gil. A differenza della lingua C o della lingua Java, che impiegano immediatamente il multiprocessing. È una spina che consente solo a un processo di eseguire contemporaneamente. Il pacchetto multiprocessing in Python, quindi, può affrontare tale problema. Ci sono due modalità in questa unità che includono il processo e il pool. Questi possono aiutarci a eseguire un pezzo di codice specifico contemporaneamente.

Sintassi della funzione pool ():

Costruiremmo esplicitamente procedure nella classe di processo. Anche se, la classe di piscina sembra essere più utile perché possiamo gestirla in modo dinamico. Per costruire un oggetto pool, utilizzare la sintassi:

Ogni parametro è facoltativo. L'iniziorgs è il terzo parametro passato al metodo, verrà inoltre fornito il parametro "Initializer", che viene utilizzato per l'inizializzazione. Il "MaxtasksperChild" indica il numero totale di operazioni che ogni processo di bambino è stato dato. Il processo verrebbe aggiornato con una nuova procedura di lavoro dopo aver completato le operazioni.

Discutiamo di ulteriori pool multiprocessing:

Esempio n. 1:
Diamo un'occhiata all'illustrazione qui sotto, che calcola il quadrato dell'intero e dorme il codice per un secondo.

tempo di importazione
Dal pool di importazioni multiprocessing
def Square (a):
print (f "qui il processo inizia: a")
quadrato = a * a
print (f "quadra a: quadra")
tempo.sonno (1)
print (f "ehere il processo termina: a")
Se __Name__ == "__main__":
start_t = time.tempo()
pool = pool ()
piscina.Mappa (quadrata, intervallo (0, 9))
piscina.vicino()
end_t = time.tempo()
print (f "Il tempo totale impiegato è end_t-start_t secondi")

All'inizio del codice, dobbiamo importare il modulo temporale e il modulo pool. La libreria del pool sarà integrata dal multiprocessing. Definiamo la funzione quadrata (). Successivamente, utilizziamo il metodo Print () per mostrare il messaggio "Qui inizia il processo". Qui, otteniamo il quadrato del numero moltiplicando il numero tra loro. Ancora una volta, chiamiamo la funzione print () per mostrare il quadrato del numero definito. Definiamo la funzione Sleep () per impostare il periodo di tempo del codice.

Ora, l'istruzione di stampa stampa la riga che mostra che il processo è terminato. Cominciamo con il corpo della funzione principale. Invochiamo il metodo tempo () del tempo del modulo. Costruiamo un articolo di classe piscina. Il metodo che vorremmo replicare e un iterabile è stato fornito come parametri al metodo Map ().

Inoltre, accetta un ulteriore parametro "chunksize" che divide l'iterabile in segmenti di dimensioni uguali e riceve questo come un'operazione distinta. Il parametro al metodo Map () viene applicato come intervallo. Per negare nuove operazioni, utilizzare il pool.Metodo Close ().

Esempio n. 2:
In questo caso, imposteremo il frame di dati del codice per 2 secondi utilizzando il metodo Sleep ().

tempo di importazione
Dal pool di importazioni multiprocessing
def Square (a):
print (f "Il processo inizia ora a")
quadrato = a * a
tempo.sonno (2)
print (f "Il processo termina ora a")
ritorno in piazza
Se __Name__ == "__main__":
pool = pool ()
x = pool.Mappa (quadrata, intervallo (0, 7))
Stampa (x)

Il pacchetto di tempo e il pacchetto pool devono essere importati all'inizio del programma. Il multiprocessing sarà incorporato con la libreria del pool. Il metodo quadra () è definito. Il messaggio "Il processo inizia ora" viene quindi mostrato utilizzando la funzione print (). Moltiplicando i valori insieme, possiamo ottenere il quadrato del numero in questo scenario.

Per impostare il tempo del codice, invochiamo il metodo Sleep (). Inoltre, il comando di stampa visualizza una riga che indica che il processo è terminato. All'interno del corpo della funzione principale, invoceremo il metodo pool (). La mappa delle funzioni () è stata utilizzata nella riga successiva. Questa funzione contiene due parametri. Il primo argomento mostra il quadrato del numero. E il secondo parametro utilizza il metodo intervallo ().

Definiamo i limiti più bassi e più alti all'interno della funzione dell'intervallo (). Alla fine, abbiamo chiamato Print () per mostrare il risultato.

Esempio n. 3:
Incredibilmente simile alla piscina.La funzione mappa () è il pool.Imap (). La distinzione qui è che il risultato di ogni elemento viene fornito immediatamente come viene elaborato, piuttosto che dover aspettare che tutti gli articoli vengano completati. Inoltre, l'iterable si trasforma in una set dalla funzione mappa (). La tecnica IMAP (), quindi, no.

tempo di importazione
Dal pool di importazioni multiprocessing
DEF Square (x1):
print (f "STHE Process ha avviato x1")
quadrato = x1 * x1
tempo.sonno (9)
print (f "Il processo è terminato x1")
ritorno in piazza
Se __Name__ == "__main__":
pool = pool ()
x2 = pool.IMAP (Square, Range (0, 4))
per j in x2:
print (f "Il risultato è qui j")

Innanzitutto, dobbiamo includere il tempo di tempo e pool. Prendiamo la libreria del pool dal pacchetto multiprocessing. Chiamiamo la funzione quadrata (). Questa funzione contiene il numero richiesto come argomento. Per visualizzare il messaggio che indica che il processo è iniziato, abbiamo chiamato la funzione di stampa (). Moltiplicando i valori insieme in questa istanza, possiamo ottenere il quadrato del numero specificato. Per determinare il tempo del codice, invochiamo il metodo sleep (). L'affermazione che indica che il processo è stato stampato dalla funzione di stampa. Il quadrato del numero intero specificato viene quindi restituito dalla funzione.

Cominciamo ora il corpo della funzione principale. Verrà utilizzata la funzione pool (). La riga successiva utilizza il metodo Map (). Esistono due parametri per questo metodo. Il quadrato dell'intero è fornito come primo parametro. La funzione intervallo () viene utilizzata come secondo argomento. All'interno del metodo dell'intervallo (), sono specificate le limitazioni inferiori e superiori. Prima di terminare il codice, utilizzeremo il ciclo "per". Inizializziamo la variabile loop. Questo ciclo si esegue fino a quando la condizione data non viene soddisfatta. Dopo questo, il metodo Print () viene applicato per rappresentare il risultato.

Conclusione

In questa guida, abbiamo parlato del pool multiprocessing di Python. Quando è necessario operare numerosi processi contemporaneamente o dovrebbe essere accelerato un'operazione lunga, il multiprocessing è vitale. Quando un processo viene eseguito su un singolo thread, le sue capacità sono vincolate; Altrimenti, questo allungherebbe i suoi tentacoli attraverso numerosi fili. Python offre una semplice interfaccia per implementare il multiprocessing se l'operazione che richiede tempo può eseguire contemporaneamente e l'intero sistema supporta molte architetture del processore. Abbiamo eseguito tre istanze in cui impostiamo il lasso di tempo del codice.