Guida definitiva: Threading in Python

Se hai appena iniziato in Python e vuoi saperne di più, prendi l’introduzione di DataCamp alla scienza dei dati nel corso Python.

Introduzione

Il threading consente di eseguire contemporaneamente diverse parti del processo (Fonte: RealPython). Queste diverse parti sono solitamente individuali e hanno un’unità di esecuzione separata appartenente allo stesso processo., Il processo non è altro che un programma in esecuzione che ha singole unità che possono essere eseguite contemporaneamente. Ad esempio, un browser Web potrebbe essere un processo, un’applicazione che esegue più telecamere contemporaneamente potrebbe essere un processo; un videogioco è un altro esempio di processo.

All’interno di un processo viene il concetto di threading multiplo o comunemente noto come multi-threading, dove più thread lavorano insieme per raggiungere un obiettivo comune. Il vantaggio più importante dell’utilizzo dei thread è che consente di eseguire il programma in parallelo.,

Comprendiamo il concetto di threading con l’aiuto di un esempio. Immagina di avere un’applicazione che conta il numero di auto che entrano ed escono dal parcheggio del centro commerciale. Il tuo apparecchio ha varie telecamere che monitorano l’entrata e l’uscita collegandosi a un dispositivo centrale. Ogni telecamera avrà un algoritmo per monitorare il flusso di auto, che apparterrà allo stesso processo o programma. Tuttavia, ogni telecamera, insieme all’algoritmo su cui viene eseguita, potrebbe far parte di un thread separato., Non solo, ma anche i fotogrammi letti dalla fotocamera e l’algoritmo che prevede i fotogrammi potrebbero essere due thread separati.

Un altro esempio potrebbe essere un videogioco in cui il processo deve eseguire le attività in parallelo come la grafica, l’interazione dell’utente e il networking (durante la riproduzione di giochi multiplayer) perché deve essere reattivo in ogni momento. E per raggiungere questo obiettivo, deve utilizzare il concetto di multi-threading, in cui ogni thread sarebbe responsabile dell’esecuzione di ogni attività indipendente e individuale.,

Un thread ha il suo flusso di esecuzione, il che significa che il processo avrà più cose che accadono contemporaneamente.

È importante notare che ogni processo ha almeno un thread, e questo è chiamato main thread. Se il tuo programma non ha alcun thread definito, allora avrà almeno il thread principale, cioè il processo stesso.

Se si guarda il diagramma sopra, c’è un processo che consiste nel thread principale costituito da variabili globali e tre diversi thread t1, t2 e t3. Ogni thread ha le sue variabili locali e il flusso di esecuzione del codice., I thread generalmente condividono le risorse del processo, come le risorse disponibili per il thread principale saranno condivise anche tra i tre thread t1, t2 e t3. Tutti i thread avranno accesso alle variabili globali pur avendo le proprie variabili locali.,

Ci sono diversi tipi di thread:

• thread del Kernel
• thread dell’Utente
• Combinazione di kernel e user thread

Ora diamo un’occhiata ad alcuni dei vantaggi di avere la filettatura nel programma:

• il Multi-threading consente al programma per velocizzare l’esecuzione, a condizione che essa ha di più Cpu.

• Consente inoltre di eseguire altre attività mentre le operazioni di I / O vengono eseguite con l’aiuto di più thread o anche thread principale insieme a un singolo thread., Ad esempio, la velocità con cui i fotogrammi della fotocamera vengono letti e dedotti dall’algoritmo verrà gestita da thread diversi. Quindi, l’algoritmo non dovrà attendere l’inserimento del frame e la parte di lettura del frame non dovrà attendere il completamento dell’esecuzione dell’algoritmo per essere in grado di leggere il frame successivo.

• I thread all’interno dello stesso processo possono condividere la memoria e le risorse del thread principale.,

Sfide del Threading:

• Ricorda che Python funziona in base all’implementazione CPython, che limita solo un thread da eseguire alla volta, quindi; il threading potrebbe non accelerare tutte le attività. E la ragione essenziale alla base di questo è Global Interpreter Lock (GIL).

  Se volete conoscere GIL, quindi sentitevi liberi di controllare questo tutorial.

• Se stai cercando di accelerare l’attività intensiva della CPU, il threading potrebbe non essere la soluzione migliore per te. In questi casi, la multi-elaborazione è considerata utile.,

• Per eseguire un programma composto da vari thread, è necessario passare rapidamente attraverso i thread; quindi, la pianificazione deve essere curata nei programmi in cui si hanno molti thread.

• La condivisione delle risorse può anche essere un problema poiché tutti i thread condividono le stesse risorse e la stessa memoria delle variabili globali. Pertanto, le operazioni eseguite in un thread potrebbero causare un errore di memoria per un altro thread o l’altro thread potrebbe non ottenere la memoria per eseguire il proprio compito.,

Threading in Python

• In Python, il modulo threading è un modulo integrato che è noto come threading e può essere importato direttamente.

• Poiché quasi tutto in Python è rappresentato come un oggetto, anche il threading è un oggetto in Python. Un thread è in grado di

  • Contenere dati,
  • Memorizzati in strutture dati come dizionari, elenchi, set, ecc.
  • Può essere passato come parametro a una funzione.

• Un thread può anche essere eseguito come processo.,

• Un thread in Python può avere vari stati come:

  • Aspetta,
  • Bloccato.

Impariamo ora come implementare il threading in Python.

Modulo thread in Python3

Si noti che Python3 è retrocompatibile con ilthread modulo, che esiste in Python2. 7. In Python3, può essere importato come_thread modulo. Quindi, facciamo un esempio e comprendiamo il modulo_thread.,

import _thread #thread module importedimport time #time module

Definiamo una funzione chiamata thread_delay, che prenderà due parametri come input, cioè il nome del thread e il ritardo. All’interno di questa funzione, è:

• Definire un contatore a zero,
• Allora in loop in giro con un ciclo while che verrà eseguito per tre volte,
• all’Interno del ciclo while, si metterà time.sleep() per aggiungere un ritardo, questo ritardo sarà utile per comprendere l’esecuzione del thread., Questo ritardo sarà in secondi,
• Quindi incrementerai il tuo contatore di 1,
• Per vedere se l’esecuzione del thread sta andando liscio, stamperai il nome del thread e l’ora in cui viene eseguito il thread.

def thread_delay(thread_name, delay): count = 0 while count < 3: time.sleep(delay) count += 1 print(thread_name, '-------->', time.time())

Ora per aggiungere la funzionalità thread sulla funzione di cui sopra o per eseguire la funzione di cui sopra nel thread, si dovrebbe usare ilstart_new_threadmetodo, che è all’interno del_thread module.

Vediamo la docstring del metodostart_new_thread.,

?_thread.start_new_thread

passiamo nella funzione thread_delay senza parentesi e i due argomenti, cioè, nome del thread e il ritardo (per visualizzare l’esecuzione di thread, dato che è molto veloce).

_thread.start_new_thread(thread_delay, ('t1', 1))_thread.start_new_thread(thread_delay, ('t2', 3))

Dall’output di cui sopra, è possibile vedere che il threadt1 inizia l’esecuzione per primo., Nel frattempo, thread t2attende che ci sia un ritardo di 3 secondi, e non appena tale ritardo è terminato, threadt2viene eseguito, e anche, il ritardo per threadt1 è solo 1 secondo.

proviamo ora a modificare il ritardo di t2 per 5 secondi, che dovrebbe iniziare t2 dopo t1 avrebbe terminato l’esecuzione, visto che t1 avrà solo 3 secondi per completare l’esecuzione.,

_thread.start_new_thread(thread_delay, ('t1', 1))_thread.start_new_thread(thread_delay, ('t2', 5))

Implementare il threading usando il modulo Threading

Usiamo lo stesso esempio che hai usato sopra, ma questa volta userai il modulo threadinginvece del modulo _thread.

import threadingimport time

def thread_delay(thread_name, delay): count = 0 while count < 3: time.sleep(delay) count += 1 print(thread_name, '-------->', time.time())

all’Interno di threading modulo Thread classe, che è uno spirito simile al start_new_thread funzione _thread modulo.,

Diamo un’occhiata alla docstring della classeThread, che accetta diversi parametri come group, target (come una funzione), args, ecc.

?threading.Thread

Nel Thread costruttore della classe, si passeranno in funzione di destinazione thread_delay e gli argomenti della funzione.,

t1 = threading.Thread(target=thread_delay, args=('t1', 1))t2 = threading.Thread(target=thread_delay, args=('t2', 3))

Nel modulo di threading, per eseguire o eseguire il thread, si utilizza il metodostart(), che è semplicemente responsabile dell’esecuzione del thread.

?t1.start

t1.start()t2.start()

Potete anche usare il join metodo, il che significa che attendere fino a quando tutti i thread di esecuzione è completa., Quindi qualsiasi codice che hai scritto dopo il metodojoin verrà eseguito solo una volta terminati questi thread.

?t1.join

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Ora calcoliamo il volume di cubo e quadrato utilizzando il concetto di threading, che è abbastanza semplice.

def volume_cube(a): print ("Volume of Cube:", a*a*a)

def volume_square(a): print ("Volume of Square:", a*a)

t1 = threading.Thread(target=volume_cube, args=(2))t2 = threading.Thread(target=volume_square, args=(3))

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Aspetta; cosa? Non appena è stato eseguito il metodo start, è risultato un errore., Che è perché il args parametro si aspetta una tupla, e dal momento che il volume_cube e volume_square prevede un solo parametro, quindi, è necessario mettere una virgola nel args parametro dopo aver specificato il primo argomento della funzione.

t1 = threading.Thread(target=volume_cube, args=(2,))t2 = threading.Thread(target=volume_square, args=(3,))

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Volume of Cube: 8Volume of Square: 9Thread execution is complete!

Impariamo ora ad usare il threading come sottoclasse.,

Threading come sottoclasse

In questa sezione, imparerai come creare sottoclasse dalla classe thread, che è disponibile all’interno del modulo threading, e quindi creare istanze threadt1 et2 fuori da quella classe.

Dovresti usare la stessa funzionethread_delay anche qui.

Ora capiamo il codice sopra passo dopo passo:

• Hai definito una classe comeDataCampThread, e nell’argomento della classe, hai passato nella classethreading.Thread., Il motivo per cui lo fai è che vuoi creare una sottoclasse dal modulo di threading. In questo modo è possibile utilizzare tutti i metodi disponibili nella classethreading.Thread simile al concetto di ereditarietà.

• Successivamente, è stato definito il metodo init della classe DataCampThread e passato nella funzione insieme al ritardo. L’init è un costruttore simile ai parametri passati alla classethreading.Thread, qui passerai alla classeDataCampThread.,

• Quindi inizializzi il metodo init del threading principale.Classe thread e quindi equiparare nome e ritardo.

• Successivamente, definisci il metodo run, ricorda qui hai definito il metodo start, che fondamentalmente sotto il cofano chiama il metodo run. Poiché hai ereditato la classe principale, puoi apportare modifiche al metodorun., Quindi, quando chiami il metodostart, tutte le modifiche che farai nel metodorun verranno riflesse ora.

Conclusione

Congratulazioni per aver terminato il tutorial.

Questo tutorial è stata un’introduzione di base al threading in python. Tuttavia, il threading è un argomento molto vasto e vitale, e alcuni concetti potrebbero essere stati lasciati inesplorati. Sentiti libero di guardare più metodi di threading come conteggio attivo, thread corrente, ecc.

Se vuoi saperne di più, controlla anche il parallelismo basato su thread di Python.,

Se hai appena iniziato in Python e vuoi saperne di più, prendi l’Introduzione di DataCamp alla scienza dei dati nel corso Python.