Python Multiprocessing Lock

Il pacchetto multiprocessing di Python consente agli utenti di creare nuovi processi e accedere all'API Python. Se hai mai giocato in giro con il modulo di threading, questo è molto comparabile. Sono necessarie molteplici prestazioni dell'attività. Dobbiamo importare il modulo multiprocessing nello script Python per eseguire operazioni multiprocessing. Quando due processi o thread tentano di accedere a una risorsa condivisa come file di memoria o altri dati, potrebbe causare problemi nel mondo della programmazione. Pertanto, dobbiamo proteggere quell'accesso utilizzando un blocco. La condivisione della memoria e degli accessori principali consente alle unità di elaborazione di eseguire i programmi contemporaneamente.

L'applicazione multiprocessing si divide in unità più piccole e funziona separatamente. Il sistema operativo assegna un processore a ciascun processo. Per impedire a un altro processo di eseguire una funzione equivalente fino al rilascio del blocco, utilizziamo la classe di blocco multiprocessing per ottenere un blocco sul processo. La classe di blocco svolge principalmente due funzioni. Il metodo acquisito () viene utilizzato per ottenere prima un blocco, mentre la funzione di rilascio () viene utilizzata per rilasciare il blocco.

L'implementazione di Python di Lock () in multiprocessing

In questo esempio, costruiamo un blocco e quindi utilizziamo il modulo multiprocessing per utilizzare il metodo Lock () dopo aver creato due processi. Possiamo generare e mantenere le nuove attività per bambini in Python utilizzando il pacchetto multiprocessing. Il componente multiprocessing semplifica la creazione di processi utilizzando un'interfaccia simile al componente di threading. Il modulo multiprocessing supporta sia la concorrenza locale che globale usando singole parti anziché thread, eliminando il blocco di interpretazione globale. Python ha un blocco mutex che può essere utilizzato con più processi contemporaneamente.blocco di classe. I processi possono costruire, acquisire e quindi rilasciare un oggetto del blocco prima di accedere a un'area vitale.

Iniziamo ora ad implementare il codice per eseguire lo script multiprocessing Python. "Spyder" viene anche utilizzato. Importiamo prima il modulo multiprocessing. Dobbiamo importare il modulo multiprocessing poiché dobbiamo creare un processo nello script. Successivamente, costruiamo una funzione definita dall'utente chiamata "funzione" e passiamo l'argomento "blocco" nella linea che segue. Il metodo acquisito () viene quindi chiamato con la frase "blocco" che fornisce un'autorità thread sopra un blocco. Un thread blocca fino a quando l'altro thread non lascia cadere il blocco se cerca di acquisirne uno che è già trattenuto da un altro thread. In quel momento, compete con ogni altro thread che cerca di cogliere il blocco. Un thread alla volta può possedere solo il blocco. L'istruzione "sezione importante" viene quindi approvata come input quando chiamiamo "print ()" nel passaggio seguente.

Quindi, nella fase successiva, chiamiamo ancora una volta la funzione "Print ()", passandola la frase "Can Can Essere solo un processo alla volta" prima di chiamare la funzione "Release ()" con il "blocco". Se fatto in questo modo, il blocco viene sempre rilasciato anche se c'è un bug o un errore all'interno della regione cruciale, definendo chiaramente l'inizio e la fine del codice protetto.

Ora che abbiamo definito una funzione con il nome "Function Run", passiamo alla fase successiva in cui creiamo un processo e quindi lo chiamiamo usando il modulo "Lock ()". Lo manteniamo nel parametro di blocco e utilizziamo "multiprocessing.blocco () "per chiamare il blocco con il processo. Ora che abbiamo creato il processo 1, usiamo "multiprocessing.processo "per chiamare la funzione in quel processo. Passiamo anche il blocco dell'argomento alla funzione usando il blocco "argu" = "e memorizza il processo 1 nella variabile" P1 ".

Quindi, nel passaggio seguente, usiamo "multiprocessing.processo "per eseguire la funzione nel processo 2 e passare la" funzione target = "mentre la memorizza nella variabile" p2 ". Il processo viene quindi avviato utilizzando la funzione "start ()" con "P1" e "P2". Nel passaggio successivo, utilizziamo "join ()" con "P1" e "P2" per attendere che l'esecuzione del processo sia terminata. Successivamente, utilizziamo il "se name = main_", che è essenzialmente un punto di ammissione. La "funzione run ()" viene quindi invocata alla fine.

Per raggiungere questo obiettivo, il processo deve prima acquisire il blocco prima di eseguire la parte essenziale. Quando la fase critica dell'attività è terminata, il processo deve rimuovere il blocco. Sia i due processi che le loro affermazioni sono stati visualizzati. Potrebbe esserci solo un'unica attività in esecuzione alla volta presentata dopo la "sezione critica."

Ora abbiamo un altro esempio di blocco multiprocessing Python. Cominciamo importando "sonno" dal modulo temporale prima di importare "casuale" dal modulo casuale. I numeri interi vengono generati in modo casuale usando un programma Python chiamato Python Random. Perché sono pseudo-casuali, questi numeri non sono veramente casuali. È possibile utilizzare questo pacchetto per eseguire altre operazioni casuali, stampare un numero casuale per un elenco o una stringa e generare i numeri casuali.

Successivamente, importa il processo dal multiprocessing nella riga seguente. Il blocco viene quindi importato dal multiprocessing. La funzione "func" viene quindi definita con gli argomenti "blocco", "identificativo" e "val" che vengono passati. Successivamente, usiamo un blocco per ottenere il blocco. Questa parte cruciale comporta la segnalazione di un messaggio e il blocco di un secondo messaggio.

Di conseguenza, eseguiamo il metodo Print () all'interno del blocco, passando l'istruzione insieme alle chiamate "Identificatore" e "Val". Il metodo "sleep ()" viene utilizzato per mettere in pausa l'esecuzione per un numero impostato di secondi. Chiamiamo quindi "val" all'interno delle sue parentesi. Il blocco condiviso viene stabilito utilizzando il metodo "Lock ()" e salvato nella variabile "blocco" appena creata quando utilizziamo la condizione "if name = main_". Successivamente, utilizziamo il metodo process () per creare un processo, passando "target = func" per chiamare la funzione nel processo insieme all'argomento "blocco", al numero costruito "x" e "casuale ()" funzione. Questo ciclo termina dopo aver completato le sue iterazioni "15". Salviamo questo processo nella variabile "p".

Qui, stabiliamo anche l'intervallo che utilizza "per" e impostando l'intervallo su "15". Il processo ora inizia chiamando il "processo.inizio()". Quindi, chiamiamo il processo con il metodo "join ()" per attendere l'esecuzione.

Quando viene eseguito l'esempio, vengono avviati quindici processi e ognuno è configurato per utilizzare la nostra funzione personalizzata. Successivamente, il processo principale attende che ciascuno dei processi del bambino si completino prima di lanciarli. Ogni processo figlio nel metodo function () cerca di afferrare il blocco. Il blocco può essere ottenuto solo da un processo alla volta. Quando ciò accade, inviano un messaggio tra cui la loro identità e per quanto tempo prevedono di dormire e l'indice è fuori servizio perché viene visualizzato nell'output non appena l'operazione è terminata.

Conclusione

Abbiamo imparato a conoscere il blocco multiprocessing Python in questo articolo. Il blocco è un concetto fondamentale nella teoria del sistema multiprocessing e operativo. Nella prima sezione dell'esempio, abbiamo creato due processi usando un blocco e li abbiamo chiamati usando un blocco per eseguire la funzione che abbiamo definito. Nella sezione seguente del codice, abbiamo usato il per loop e impostato l'intervallo su "15" per eseguire il processo. Il processo viene terminato una volta completata le sue iterazioni "15". Nella seconda sezione, abbiamo anche utilizzato la tecnica "sleep ()" per ritardare l'esecuzione per un breve periodo.