Python Multithreading

“All'interno di un processo, un'unità di esecuzione è nota come thread. Spostando rapidamente l'attenzione della CPU tra i thread, numerosi thread possono essere eseguiti contemporaneamente in un processo noto come multithreading (chiamato anche commutazione del contesto). Le basi di Python Multithreading saranno trattate in questo articolo. Per il tuo aiuto, forniremo anche una varietà di esempi."

Multithreading in Python

Multithreading è una tecnica di threading utilizzata nella programmazione Python per eseguire molti thread contemporaneamente. Inoltre, consente la condivisione del proprio spazio di dati con i thread primari all'interno di un processo, che comunicano e condividono le informazioni più facilmente rispetto ai processi separati. L'obiettivo di Multithreading è quello di eseguire numerosi processi contemporaneamente, il che migliora il rendering e le prestazioni dell'applicazione.

È un metodo molto pratico per accelerare e migliorare la funzionalità di un'applicazione. Utilizzando il multithreading, un programmatore può abbattere i compiti di applicazione in lavori più piccoli ed eseguire più istanze del programma contemporaneamente. Consente ai thread di comunicare tra loro e condividere le risorse del processore, inclusi memoria, file e dati. Inoltre, rende gli utenti più disposti a continuare a utilizzare un programma anche quando una sezione viene bloccata o troppo lunga.

Esempio 1

Ecco un semplice programma Python per il multithreading. Diamo un'occhiata a un programma Python che ha due classi, "Python_demo" e "Python_lesson."Diamo un'occhiata a questo codice di esempio in dettaglio.

Due delle nostre classi usano tecniche simili. L'output della funzione di corsa dell'oggetto della prima classe quando è costruito e stampato la frase "demo di Python" quattro volte. La parola "lezione di Python" appare quattro volte quando ripetiamo il processo per la seconda classe.

Classe python_demo:
def run (self):
per i nell'intervallo (4):
Stampa ("Python Demo")
Classe Python_lesson:
def run (self):
per i nell'intervallo (4):
Stampa ("Lezione Python")
First_obj = python_demo ()
Second_obj = python_lesson ()
First_obj.correre()
Second_obj.correre()

Il risultato se eseguiamo questo programma è il seguente. La lezione demo e Python di Python sono mostrati quattro volte di successione, come puoi vedere. Di conseguenza, il thread principale è dove questo programma esegue. Ogni programma contiene il thread principale. In questo caso, entrambe le operazioni vengono eseguite in una sequenza.

Esempio 2

Impiegheremo come esempio il modulo di threading di Python. Potremmo capire la necessità di multithreading se consideriamo il primo scenario. Ciò implica che entrambe le procedure devono essere utilizzate contemporaneamente. La classe thread e il pacchetto di threading di Python possono essere utilizzati per raggiungere questo obiettivo. Proviamo a pensare a qualcosa. Ora che è presente multithreading, il programma di esempio è stato aggiornato. Inoltre, ogni classe è stata eseguita come thread utilizzando la classe thread.

Abbiamo anche fatto la differenza non chiamando direttamente il metodo di corsa. Invece, utilizziamo il metodo iniziale, che è fondamentalmente il meccanismo di implementazione del threading.

Quando applichiamo il metodo di avvio, la funzione di esecuzione viene immediatamente chiamata in background. Attualmente eseguiamo il thread principale per impostazione predefinita. Si formano due thread di bambini, il primo OBJ e il secondo OBJ.

dall'importazione di threading *
Classe python_demo (thread):
def run (self):
per i nell'intervallo (4):
Stampa ("Python Demo")
Classe Python_lesson (thread):
def run (self):
per i nell'intervallo (4):
Stampa ("Lezione Python")
First_obj = python_demo ()
Second_obj = python_lesson ()
First_obj.inizio()
Second_obj.inizio()

Queste regolazioni derivano dall'output visualizzata di seguito. Ora che l'applicazione è in esecuzione, si può vedere multithreading. Possiamo vedere che diverse parole sono raggruppate insieme, nonostante il fatto che "Python Demo" e "Python Lesson" siano due frasi separate. Ciò è derivato da una collisione. Succede a seguito di due thread (First_obj e Second_obj) che cercano di eseguire sulla CPU contemporaneamente a causa dell'eccessiva velocità del processore.

Esempio 3

Gli scheduler nel sistema operativo specificano l'orario di esecuzione. In questo esempio, le istruzioni vengono eseguite dal software più di una volta in un momento specifico.

Possiamo impedirlo utilizzando l'approccio del sonno per fornire un piccolo ritardo al nostro software. Per raggiungere questo obiettivo, dobbiamo importare la funzione di sonno dal modulo Time per aggiungere una breve pausa tra l'esecuzione dei due thread. Ad eccezione dell'aggiunta della funzione di sonno, il codice è praticamente identico agli esempi di prima.

Notare i moduli, il threading e il sonno. Questi moduli vengono importati per primi. La funzione di sonno viene quindi eseguita in due classi che vengono successivamente costruite. Al fine di stampare la frase un certo numero di volte nel nostro caso, tre-noi hanno utilizzato il loop in entrambe le classi. Per eseguire l'applicazione, abbiamo invocato il metodo Start () dopo aver implementato l'approccio di threading. Le righe finali del codice del programma dimostrano questo.

dall'importazione di threading *
Dal tempo Import Sleep
Classe python_demo (thread):
def run (self):
per i nell'intervallo (3):
Stampa ("Python Demo")
sonno (1)
Classe Python_lesson (thread):
def run (self):
per i nell'intervallo (3):
Stampa ("Lezione Python")
sonno (1)
First_obj = python_demo ()
Second_obj = python_lesson ()
First_obj.inizio()
dormire (0.3)
Second_obj.inizio()

Il risultato ora dimostra che i thread sono in esecuzione contemporaneamente.

Esempio 4

Il modulo di threading in Python viene utilizzato per costruire thread nel seguente frammento di codice. Il thread principale funziona nel codice e le parole "questo è il thread principale" sono stampate. Il primo thread e il secondo thread sono due thread appena stabiliti ed in esecuzione. C'è una transizione di contesto e il primo thread inizia a funzionare.

Il primo thread va a dormire dopo le prime quattro iterazioni, mentre il secondo thread inizia a funzionare e completa appena in tempo per il prossimo interruttore di contesto.

La CPU è ora sotto il controllo del thread principale, che scrive di nuovo "thread principale!"

Il secondo thread riprende la sua esecuzione dopo un altro interruttore di contesto e completa. Il thread principale non può più eseguire ulteriori istruzioni; Da qui il programma finisce.

Importa threading come TD
tempo di importazione come t
def print_welcome ():
per i nell'intervallo (5):
Se i == 4:
T.sonno (2)
stampa ("benvenuto")
Def Print_Integers (N):
per i nell'intervallo (n+1):
Stampa (i)
stampa ("Questo è il thread principale.")
first_thread = td.Thread (target = print_welcome, args = ())
Second_Thread = td.Thread (target = print_integer, args = (10,))
First_Thread.inizio()
Second_Thread.inizio()
stampa ("thread principale di nuovo!")

Puoi vedere l'output in questa sezione, in cui il thread principale esegue per primo e il messaggio viene ripetuto secondo necessità. In seguito all'esecuzione del secondo thread, che ha visualizzato i numeri, il software è tornato al primo thread e ha svolto la funzione che mostra la parola "Welcome."

Conclusione

L'argomento di questo articolo era Python Multithreading. Cambiando rapidamente tra i thread usando una CPU, MultithReading è una tecnica di threading utilizzata nella programmazione Python per eseguire molti thread contemporaneamente. Inoltre, consente la condivisione del proprio spazio di dati con i thread primari all'interno di un processo, che comunicano e condividono le informazioni più facilmente rispetto ai processi separati. L'obiettivo di Multithreading è quello di eseguire numerosi processi contemporaneamente.