Esempio multiprocessing di Python

Python è un linguaggio di programmazione utile nello sviluppo di siti Web e applicazioni. Inoltre, coinvolto nella visualizzazione e nell'analisi dei dati. È comparativamente un linguaggio facile e viene spesso utilizzato anche da non programmatori. Questo articolo si riferisce all'uso del multiprocessing in Python.

Multiprocessing

Il multiprocessing si occupa del potenziale di un sistema che supporta più di un processore alla volta. Tutte le applicazioni in multiprocessing vengono demolite in piccoli schemi e ciascuno di questi schemi è auto-dipendente nel lavoro. In questo tipo di processo, vengono utilizzati due o più processi. Consideriamo solo che un computer è in esecuzione con l'uso di un singolo processore. Se assegniamo diversi processori contemporaneamente, spargerà ogni attività di trasmissione a un'altra attività dopo un breve periodo di tempo per mantenere tutti i processi in esecuzione. In altre parole, se ci sono più compiti da svolgere, più difficili, sarà mantenerli sulla buona strada del completamento. Mentre allocare ogni compito è anche una grande sfida. In questa condizione, dobbiamo sorgere il concetto di multiprocessing. Un sistema multiprocessing può consentire.

• Multiprocessore: Un computer che utilizza più di un processore centrale.
• Processore multi-core: Un singolo componente che utilizza due o più unità di elaborazione.

Multiprocessing in Python

Utilizzando il concetto di multiprocessing, l'unità di elaborazione centrale può facilmente eseguire diverse attività alla volta. Python utilizza il modulo multiprocessing per introdurre codici paralleli. Per implementare il multiprocessing, devi prima conoscere il numero di core nel tuo sistema. Abbiamo usato un singolo pezzo di codice qui per conoscere le CPU che lavorano alla volta.

Per Python, è possibile utilizzare qualsiasi altro strumento per realizzare i codici. Abbiamo usato lo strumento Spyder per questo scopo che sicuramente eseguirà i codici di lingua Python.

Import Multiprocessing

Stampa ("Numero di CPU:", multiprocessing.cpu_count ())

In primo luogo, dobbiamo importare il multiprocessing del pacchetto "PG" che consentirà il lavoro. Per ogni PC, l'output può variare. Per me, il numero di core è 4.

Esempio 1:

Usando un modulo multiprocessing, calcoleremo le funzioni cubi e quadrate.

Facciamo capire il codice sopra menzionato. Abbiamo creato un processo e quindi abbiamo creato un oggetto per elaborare la classe.

P1 = multiprocessing.Process (print (print_cube (5,)))
P2 = multiprocessing.Process (print (print_square (2,)))

P1 e P2 sono gli oggetti dei processi. Questi processi contengono la chiamata funzionale con una funzione di stampa che chiamerà direttamente la funzione con argomenti come parametro. Print_cube e print_square.

Usiamo i metodi di avvio per avviare il processo.

P1.inizio()
P2.inizio()

Una delle funzioni utilizzate è descritta come.

def print_square (num):
Print ("Square: ".Formato (num * num))

La funzione quadrata calcolerà il quadrato moltiplicando il numero dato utilizzato nella chiamata di funzione. La funzione prende il numero nella variabile "num".

Quando eseguiamo il codice, l'output visualizzerà i valori risultanti di entrambe le funzioni.

Esempio 2:

Utilizzando le strutture di dati, è necessario avere familiarità con l'uso di stack e code nel linguaggio di programmazione. Dal modulo multiprocessing, importiamo una classe di coda qui che è FIFO (prima nella prima) struttura dei dati. Ci saranno due processi che funzionano in alternativa. Usiamo due funzioni qui. La funzione put () viene utilizzata qui per inserire i dati nella coda. Mentre usiamo Get () per recuperare gli elementi dalla coda. Di seguito è riportato il codice che illustra il funzionamento del multiprocesso nella coda. Il primo passo è introdurre le code.

Dalla coda di importazione multiprocessing

Dopo aver importato il modulo, introdurre i nomi delle auto nella variabile dell'array. Useremo un ciclo per inserire i valori all'interno della coda e il put () lo farà così. Una variabile "CNT" viene utilizzata per contare il numero di auto utilizzate. Inizializza l'oggetto coda tramite l'istruzione.

Queue = queue ()

Quindi viene utilizzato un ciclo per aggiungere valori; Questo utilizzerà una parola chiave "coda" per utilizzare la funzione put () per discutere come il nome dell'auto da inserire. La funzione "CNT" verrà incrementata dopo ogni inserimento.

Per l'auto in auto:

Coda.put (auto)
Cnt += 1

Allo stesso modo, per put (), un ciclo while viene utilizzato fino a quando l'intera coda non è vuota.

Sebbene non in coda.vuoto():

Stampa ('articolo n.:', Cnt, ", coda.Ottenere())
Cnt+= 1

L'output mostra entrambe le funzioni che funzionano in modo indipendente. Una volta che una funzione completa il suo lavoro, l'altro processo viene utilizzato.

Esempio 3:

Questo esempio contiene due processi. In ogni processo, "PID" si ottiene tramite la funzione get (). Abbiamo usato due moduli. Uno è multiprocessing e l'altro è sistema operativo.

A ogni processo viene assegnato un ID diverso.

DEF processo ():

Print ("ID del processo in esecuzione di Worker1: ".Formato (sistema operativo.getpid ()))

Il messaggio è concatenato con la chiamata della funzione per ricevere l'ID processo. Nel programma principale, l'ID del processo principale viene recuperato utilizzando lo stesso approccio tramite Get (). Quindi i processi vengono creati attraverso il multiprocessing. A ogni processo si accede attraverso i rispettivi oggetti. io.e., Per il processo 1, l'oggetto è P1.

P1 = multiprocessing.Process (Target = Process1)

Target è la funzione che deve essere eseguita dal processo. Man mano che vengono creati i processi, devono iniziare. Viene visualizzato lo stato di ciascun processo; Per questo, dobbiamo monitorare il completamento del processo. Questo avrà bisogno di un po 'di tempo per aspettare. Useremo una funzione che aspetterà fino alla completa esecuzione del processo.

P1.giuntura()

Quando questa funzione di join ottiene il segnale, stampa l'istruzione che l'esecuzione è completata. Una bandiera booleana determinerà o il processo è vivo o no; Se sì, allora è vero, altrimenti è falso.

Print ("Process p1 è vivo: ".Formato (P1.è vivo()))

Ora esegui il programma e prendi l'output. Puoi prima visualizzare l'ID principale e quindi l'ID processo di ciascun processo. Al termine dell'esecuzione, lo stato viene visualizzato per entrambi i processi, che è "falso".

Esempio 4:

In questo esempio, vedrai il funzionamento del tempo multiprocessing e di importazione, pool, cpu_count. Il pool viene utilizzato per eseguire processi con più input e distribuire questi dati di input tra i processi. Una funzione quadrata calcolerà il quadrato del valore di ingresso. Usando il modulo Time dal pacchetto, useremo la funzione di sospensione.

Tempo.sonno (3)

Questa funzione ha un'espansione del tempo di 3 secondi. Significa che il valore di questa funzione verrà mostrato dopo questo tempo specifico. Nel programma principale, iniziamo il timer e quindi vengono assegnati i valori fittizi di ogni 4 core.

Con piscina () come piscina:

Res = Pool.Mappa (quadrati, valori)
Stampa (Res)

La funzione pool sta dando valori e chiama la funzione contemporaneamente. Quindi dobbiamo fermare il timer. Questa funzione Timer conterà i secondi utilizzati per questa funzione, nota come tempo trascorso; Si ottiene sottraendo il valore iniziale del tempo dal valore finale.

Ora esegui il programma. Viene visualizzata la prima riga, quindi ci vogliono 3 secondi. Dopodiché, viene mostrato un altro risultato.

Conclusione

"Python Multiprocessing Esempio" è una breve introduzione al fenomeno multiprocessing. Ogni esempio spiegato qui importa pacchetti diversi dal modulo multiprocessing. Questa gestione dei processi parallelamente l'uno con l'altro è realizzata attraverso il numero di CPU. Più il numero di CPU maggiori sarà la possibilità di un buon multiprocessing.