Threading in Python: Rendi il tuo codice più intelligente
Python è fantastico e lo sappiamo. Ma, Puoi essere abbastanza intelligente negli aspetti di elaborazione?? Il threading mostra la strada.
Cos'è il parallelismo??
Le macchine precedenti avevano un singolo core all'interno della CPU in cui avveniva tutta l'elaborazione..
Perché il numero di core è importante?? È perché indica la capacità della macchina di gestire più cose.. Se hai 16 nuclei, può eseguire 16 Operazioni diverse contemporaneamente.
Supponiamo che tu voglia eseguire 16 diverse operazioni di addizione e supponiamo che ogni operazione richieda 1 secondo. Su una macchina single-core, È necessario eseguire queste operazioni una alla volta, che significa che 16 Le operazioni di aggiunta vengono eseguite in 16 secondi. Ora, su un 16 nuclei, È possibile implementare il comando 16 Aggiungi operazioni su ciascun core contemporaneamente e fai il lavoro in 1 secondo. È chiamato Parallelismo.
Filo
Filo è un insieme di operazioni che devono essere eseguite. Il thread verrà implementato in uno dei core della CPU. Nota: 1 Hilo può essere distribuito solo in 1 nucleo, Impossibile trasferire / Cambiare i denti
Distribuiamo due thread in un unico core. Nota: Un kernel può fare solo una cosa alla volta.
Ora possiamo elaborare i due thread nel modo desiderato.
Primo, Possiamo elaborare metà del primo thread.
La metà del thread successivo può ora essere elaborata.
La metà rimanente dei thread può essere elaborata in modo simile.
Ecco cos'è il threading Ecco come eseguiamo cose diverse sullo stesso core della CPU. TLDR- Il threading riguarda il modo in cui gestiamo i thread in un kernel.
Nota- L'esecuzione di thread non comporta l'esecuzione multi-core. Si tratta di come sequenziare l'insieme di programmi (Discussioni) nello stesso nucleo. Nell'esempio sopra, diremo alla CPU come sequenziare ed eseguire i due thread sul kernel dato.
Infatti, È possibile visualizzare il numero di thread attualmente in esecuzione sul computer. In Windows: vai a Task Manager → → Prestazioni CPU.
Perché abbiamo bisogno di threading? Perché non possiamo elaborare un thread alla volta e passare al successivo?
Qualche volta, Un filo può essere appeso, il che significa che dovrebbe essere inattivo in quel momento. L'esempio migliore è la funzione time.sleep (), che non fa altro che aspettare un certo periodo di tempo. Mentre un thread è inattivo / impiccato, Possiamo andare avanti ed elaborare l'altro thread fino all'attivazione del thread precedente. TLDR: Quando un thread è in attesa, può elaborare l'altro thread nel frattempo.
Questo è esattamente ciò che chiamiamo CCalcolo attuale.
Un piccolo esempio
Spieghiamo il threading con un piccolo esempio. Vedi il frammento di codice qui sotto.
#Parte prima del codice
import time
print(1)
tempo.dormire(10)
Stampa('Finito di dormire)
Stampa(2)
#Parte seconda del codice
Stampa(3)
Quando si esegue tutto il codice come singolo thread, Il codice viene eseguito passo dopo passo. Primo, La libreria viene importata. Quindi viene stampato '1'. I fili dormono durante 10 secondi. Quanto segue è stampato “2” seguito da “Pronto a dormire” e infine il “3”.
Produzione- 1 Fatto dormire 2 3
Ora supponiamo che tu stia eseguendo il codice come due thread. La prima parte come filo e la seconda come filetto. (Nota: per impostazione predefinita, Il codice Python non viene fornito con i thread; abbiamo bisogno di importare il filo biblioteca per farlo.)
Primo, La libreria viene importata e quindi viene stampato '1'. Ora il thread va a dormire. È qui che entra in gioco il threading.
Il core passa ora all'altro thread.
Ora stampa '3'. Poiché l'intero processo viene eseguito sul thread 2, Il kernel ora ritorna al thread 1 (che è ancora sospeso).
Ora, dopo la durata del sonno, Stampa '2'.
Quindi l'output sarà
Produzione- 1 3 Fatto dormire 2
Esempio pratico
Come sempre, Un concetto è chiaro solo quando lo spieghiamo con un esempio del mondo reale.. I processi di E / S sono quelli che beneficiano del thread.
Supponiamo che tu stia guardando Shawshank Redemption su Netflix. Ora accadono due cose mentre guarda Andy Dufresne soffrire in prigione: un: L'applicazione ottiene i dati dal server, A partire dal: I dati ottenuti vengono visualizzati come un filmato sullo schermo.
Immagina quale sarebbe la situazione senza threading. Dovresti aspettare che il video venga scaricato di volta in volta, Visualizzare il segmento ottenuto, Attendi il download del segmento successivo, eccetera.
Grazie al filo, Possiamo dividere i due processi in diversi sotto-processi. Mentre un thread ottiene i dati (vale a dire, è in modalità di sospensione / sospensione), l'altro thread potrebbe mostrarti la sorprendente performance di Morgan Freeman.
È anche molto utile per te come data scientist. Ad esempio, Quando si estraggono dati da più pagine Web, Puoi semplicemente distribuirli su più thread e farlo più velocemente. Anche quando si inviano i dati a un server, Puoi farlo su più thread, in modo che quando un thread è inattivo, Altri possono essere attivati.
Un esempio dettagliato
Come detto prima, per impostazione predefinita, Il codice Python non è threaded; Abbiamo bisogno di importare la libreria di thread per farlo.
Dai un'occhiata al codice.
import threading
import time
def sleepy_man(Secs):
Stampa('Iniziare a dormire dentro')
tempo.dormire(Secs)
Stampa('Mi sono svegliato dentro')
x = filettatura. Filo(target = sleepy_man, args = (1,))
x.start()
Stampa(threading.activeCount())
tempo.dormire(1.2)
Stampa('Fatto')
Se si esegue il codice precedente, Otterrai il seguente risultato.
Produzione-
Iniziare a dormire dentro
2
Woke up inside
Done
Primo, Lascia che ti spieghi il codice passo dopo passo. Quindi analizzeremo l'output.
- Importare la libreria filo e tempo metereologico. filo È la libreria che ci permetterà di creare thread e tempo metereologico è la libreria che contiene la funzione di sospensione.
- La funzione hombre_soñoliento Prendere in considerazione una discussione secondi. Prima stampa 'Iniziare a dormire dentro'. Quindi dormi per il secondi secondi e poi stampa 'Mi sono svegliato dentro'.
- Questa è la parte in cui iniziamo a creare thread. Dobbiamo definire chiamando la classe filo. Dobbiamo passare due argomenti: obbiettivo Qual è il blocco di funzioni che deve essere filettato, argomenti Quali sono gli argomenti che dovrebbero essere passati alla funzione. Viene restituito un oggetto thread che viene ora memorizzato in x.
x = filettatura. Filo(target = sleepy_man, args = (10,))
- Ora, Dopo aver definito la classe di thread, Dobbiamo chiamare la funzione cominciare() Per avviare il threading
- Nota- Ora abbiamo due thread. Un thread predefinito per il programma e un
Nuovo thread che definiamo. Perciò, Il numero di thread attivi è due. - Perciò, La dichiarazione deve riportare '2'.
Stampa(threading.activeCount())
Ora diamo un'occhiata al flusso di controllo. Una volta chiamato il cominciare() metodo, Sparare hombre_soñoliento () e viene eseguito su un thread separato. Il programma principale verrà eseguito anche in parallelo come un altro thread. Il flusso è mostrato nell'immagine sottostante.
Ora aumentiamo il tempo in cui il programma dorme all'interno della funzione.
import threading
import time
def sleepy_man(Secs):
Stampa('Iniziare a dormire dentro')
tempo.dormire(Secs)
Stampa('Mi sono svegliato dentro')
x = filettatura. Filo(target = sleepy_man, args = (4,))
x.start()
Stampa(threading.activeCount())
tempo.dormire(1.2)
Stampa('Fatto')
L'output è il seguente:
Iniziare a dormire dentro
2
Done
Woke up inside
Il flusso è indicato nel diagramma sottostante:
Ora rendiamo le cose un po 'più piccanti.. Eseguiamo un ciclo for che genera più thread.
import threading
import time
def sleepy_man(Secs):
Stampa("Iniziare a dormire dentro - Iterazione {}'.formato(5-Secs))
tempo.dormire(Secs)
Stampa('Mi sono svegliato dentro - Iterazione {}'.formato(5-Secs))
per io nel raggio d'azione(3):
x = filettatura. Filo(target = sleepy_man, args = (5-io,))
x.start()
Stampa(«Discussioni attive- ', threading.activeCount())
In ogni iterazione, Attiviamo un thread. Si noti che sono stati passati gli argomenti 5, 4, 3 un 1Ns, 2Nord Dakota, e 3rd iterazione rispettivamente. Perciò, il hombre_soñoliento () Dormire 5 secondi, 4 secondi e 3 secondi rispettivamente.
Perciò, L'output è come mostrato:
Iniziare a dormire dentro - Iterazione 0 Iniziare a dormire dentro - Iterazione 1 Iniziare a dormire dentro - Iterazione 2 Thread attivi- 4 Mi sono svegliato all'interno - Iterazione 2 Mi sono svegliato all'interno - Iterazione 1 Mi sono svegliato all'interno - Iterazione 0
Perciò, Abbiamo visto come è possibile definire e attivare più thread, che garantisce un modo migliore di elaborazione, che è molto essenziale per le operazioni E / S pesante.
Il supporto mostrato in questo articolo non è di proprietà di DataPeaker e viene utilizzato a discrezione dell'autore.
