Python Multiprocessing Coda

L'elemento più cruciale della struttura dei dati è la coda. La coda della struttura dei dati "First In, First Out" che è la base per il multiprocessing di Python è comparabile. Le code sono fornite alla funzione di processo per consentire al processo di raccogliere i dati. Il primo elemento di dati da eliminare dalla coda è il primo elemento da inserire. Utilizziamo il metodo "Put ()" della coda per aggiungere i dati alla coda e il suo metodo "get ()" per recuperare i dati dalla coda.

Esempio 1: usando il metodo Queue () per creare una coda multiprocessing in Python

In questo esempio, creiamo una coda multiprocessing in Python usando il metodo "Queue ()". Il multiprocessing si riferisce all'utilizzo di una o più CPU in un sistema per eseguire due o più processi contemporaneamente. Il multiprocessing, un modulo costruito in Python, facilita il cambio da un processo. Dobbiamo avere familiarità con la proprietà del processo prima di lavorare con il multiprocessing. Siamo consapevoli che la coda è una componente cruciale del modello di dati. La coda di dati standard, che si basa sull'idea "prima in primo luogo", e il multiprocessing di Python è controparti esatte. In generale, la coda memorizza l'oggetto Python ed è cruciale per il trasferimento dei dati tra le attività.

Lo strumento "Spyder" viene utilizzato per implementare lo script Python presente, quindi iniziamo semplicemente. Dobbiamo prima importare il modulo multiprocessing perché stiamo eseguendo lo script multiprocessing Python. Lo abbiamo fatto importando il modulo multiprocessing come "M". Usando il “m.Tecnica Queue () ", invochiamo il metodo multiprocessing" Queue () ". Qui, creiamo una variabile chiamata "coda" e posizioniamo il metodo "queue ()" multiprocessing in esso. Come sappiamo che la coda memorizza gli articoli in un ordine "primo, primo out", l'articolo che aggiungiamo per primo viene rimosso per primo. Dopo aver lanciato la coda multiprocessing, chiamiamo quindi il metodo "Print ()", passando l'istruzione "C'è una coda multiprocessing" come argomento per visualizzarla sullo schermo. Quindi, poiché archiviamo la coda costruita in questa variabile, stampiamo la coda passando la variabile "coda" nella parentesi del metodo "print ()".

La seguente immagine mostra che è ora costruita la coda multiprocessing Python. L'istruzione di stampa è mostrata prima. Dopo che questa coda multiprocessing è stata costruita nell'indirizzo di memoria designato, può essere utilizzato per trasferire i dati distinti tra due o più processi in esecuzione.

Esempio 2: utilizzando il metodo "QSize ()" per determinare la dimensione della coda multiprocessing in Python

Determiamo le dimensioni della coda multiprocessing in questo caso. Per calcolare la dimensione della coda multiprocessing, utilizziamo il metodo "QSIZE ()". La funzione "QSize ()" restituisce la dimensione reale della coda multiprocessing Python. In altre parole, questo metodo fornisce il numero totale di elementi in una coda.

Cominciamo importando il modulo multiprocessing Python come "M" prima di eseguire il codice. Quindi, usando il “m.comando queue () ", invochiamo la funzione multiprocessing" queue () "e mettiamo il risultato nella variabile" coda ". Quindi, usando il metodo "put ()", aggiungiamo gli elementi alla coda nella riga seguente. Questo metodo viene utilizzato per aggiungere i dati a una coda. Pertanto, chiamiamo "coda" con il metodo "put ()" e forniamo i numeri interi come elemento nella sua parentesi. I numeri che aggiungiamo sono "1", "2", "3", "4", "5", "6" e "7" usando le funzioni "put ()".

Inoltre, usando la "coda" per ottenere le dimensioni della coda multiprocessing, chiamiamo "QSize ()" con la coda multiprocessing. Quindi, nella variabile "risultato" appena formata, salviamo il risultato del metodo "QSIZE ()". Successivamente, chiamiamo il metodo "Print ()" e passiamo l'istruzione "La dimensione della coda multiprocesso è" come parametro. Successivamente, chiamiamo la variabile "risultato" nella funzione "print ()" poiché la dimensione viene salvata in questa variabile.

L'immagine di output ha la dimensione visualizzata. Mentre utilizziamo la funzione "put ()" per aggiungere sette elementi alla coda multiprocesso. L'istruzione di input "La dimensione della coda multiprocessing" è mostrata prima della dimensione.

Esempio 3: usando il metodo "Put ()" e "Get ()" nella coda multiprocessing Python

I metodi di coda "Put ()" e "Get ()" dalla coda multiprocessing Python sono usati in questo esempio. In questo esempio sviluppiamo due funzioni definite dall'utente. In questo esempio, definiamo una funzione per creare un processo che produce numeri interi casuali "5". Usiamo anche il metodo "Put ()" per aggiungerli a una coda. Il metodo "Put ()" viene utilizzato per posizionare gli elementi nella coda. Quindi, per recuperare i numeri dalla coda e restituire i loro valori, scriviamo un'altra funzione e la chiamiamo durante la procedura. Usiamo la funzione "get ()" per recuperare i numeri dalla coda poiché questo metodo viene utilizzato per recuperare i dati dalla coda che inseriamo usando il metodo "put ()".

Iniziamo a implementare il codice ora. Innanzitutto, importiamo le quattro librerie che compongono questo script. Prima importamo "sonno" dal modulo temporale per ritardare l'esecuzione per un po 'di tempo misurato in secondi, seguito da "casuale" dal modulo casuale che viene utilizzato per generare numeri casuali, quindi "processo" dalla multiprocessing perché questo codice crea un processo , e infine, la "coda" dal multiprocessing. Inizialmente costruendo un'istanza di classe, la coda può essere utilizzata. Per impostazione predefinita, ciò stabilisce una coda infinita o una coda senza dimensioni massime. Impostando l'opzione dimensione massima su un numero maggiore di zero, è possibile fare una creazione con una restrizione di dimensioni.

Definiamo una funzione. Quindi, poiché questa funzione è definita dall'utente, gli diamo il nome "function1" e passiamo il termine "coda" come argomento. Successivamente, invochiamo la funzione "print ()", passandola "in esecuzione", "filo" e oggetto "vero" . La funzione di stampa di Python ha un'opzione univoca chiamata FLOH che consente all'utente di scegliere se tamponare o meno questo output. Il prossimo passo è generare l'attività. Per fare ciò, utilizziamo "per" e creiamo la variabile "M" e impostiamo l'intervallo su "5". Quindi, nella riga successiva, usa "Random ()" e memorizza il risultato nella variabile che abbiamo fatto che è "Valore."Ciò indica che la funzione ora termina le sue cinque iterazioni, con ogni iterazione che crea un numero intero casuale da 0 a 5.

Quindi, nel passaggio seguente, chiamiamo la funzione "sleep ()" e passiamo l'argomento "valore" per ritardare la parte per un certo numero di secondi. Quindi, chiamiamo la "coda" con il metodo "put ()" per aggiungere essenzialmente il valore alla coda. L'utente viene quindi informato che non c'è altro lavoro da fare invocando la "coda.Put () "Metodo ancora una volta e passando il valore" nessuno ". Quindi, eseguiamo il metodo "Print ()", passiamo la dichiarazione "Builder: Ready" insieme a "Flush" e lo imposta su "True".

Ora definiamo una seconda funzione, "funzione2" e assegniamo la parola chiave "coda" come argomento ad essa. Quindi, chiamiamo la funzione "Print ()" mentre passiamo il report afferma "Utente: Esecuzione" e "Flush" che è impostato su "True". Iniziamo il funzionamento di "function2" utilizzando la condizione while vera per eliminare i dati dalla coda e inserirli nella variabile "elemento" appena creata. Quindi, utilizziamo la condizione "if", "L'elemento non è nessuno", per interrompere il ciclo se la condizione è vera. Se non è disponibile alcun articolo, si ferma e chiede all'utente uno. L'attività interrompe il ciclo e la fine in questo caso se l'elemento ottenuto dal valore è nullo. Quindi, nel passaggio seguente, chiamiamo la funzione "Print ()" e forniamo il rapporto "Utente: pronto" e "flush = true".

Quindi, inseriamo il processo principale utilizzando "if-name = main_". Creiamo una coda chiamando il metodo "queue ()" e memorizzandolo nella variabile "coda". Successivamente, creiamo un processo chiamando la funzione utente "funzione2". Per questo, chiamiamo la classe "processo". All'interno di esso, passiamo "Target = function2" per chiamare la funzione nel processo, passiamo l'argomento "coda" e lo archivialo nella variabile "utente_process". Il processo si avvia quindi chiamando il metodo "start ()" con la variabile "Process User_". Ripetiamo quindi la stessa procedura per chiamare la "funzione1" nel processo e inserirla nella variabile "Processo del costruttore". Quindi, chiamiamo i processi con il metodo "join ()" per attendere l'esecuzione.

Ora che è presentato, puoi vedere le dichiarazioni di entrambe le funzioni nell'output. Visualizza gli elementi che abbiamo aggiunto usando i metodi "put ()" e "get ()" utilizzando rispettivamente i metodi "get ()",.

Conclusione

Abbiamo appreso della coda multiprocessing di Python in questo articolo. Abbiamo utilizzato le illustrazioni fornite. Inizialmente, abbiamo descritto come creare una coda nel multiprocessing di Python usando la funzione coda (). Quindi, abbiamo usato il metodo "QSize ()" per determinare la coda . Abbiamo anche usato i metodi di coda put () e get (). La classe del sonno del modulo temporale e la classe casuale del modulo casuale sono state entrambi discussi nell'ultimo esempio.