Ce este Mutithreading-ul în Python și cum să-l realizăm?

Timpul este cel mai critic factor din viață. Datorită importanței sale, lumea programării oferă diverse trucuri și tehnici care vă ajută în mod semnificativ să reduceți consumul de timp, sporind astfel performanța. O astfel de abordare este Multithreading în Python, care este unul dintre cele mai importante concepte acoperite .

Iată un rezumat rapid al tuturor elementelor majore acoperite în acest articol:

Ce este multifunctional în Python?
Ce este un fir?
Ce este multithreading în Python?
Când se folosește multithreading în Python?
Cum se realizează Multithreading în Python?
Cum se creează fire în Python?

• fără a crea o clasă
• prin extinderea clasei de fire
• fără a extinde clasa de fire

Avantajele utilizării multithreading-ului în Python

Pentru început, să încercăm mai întâi să înțelegem multitasking-ul înainte de a începe să învățăm despre Multithreading în Python.

cum se scrie un scaner în java

Ce este Multitasking în Python?

Multitaskingul, în general, este capacitatea de a efectua mai multe sarcini simultan. În termeni tehnici, multitaskingul se referă la capacitatea unui sistem de operare de a efectua diferite sarcini în același timp. De exemplu , descărcați ceva de pe computer, ascultați melodii și jucați simultan un joc etc. Toate aceste sarcini sunt efectuate de același sistem de operare și sincronizat. Acest lucru nu este altceva decât multitasking, care nu doar vă ajută să economisiți timp, ci și creșteți productivitatea.

Există două tipuri de multitasking într-un sistem de operare:

• Bazat pe proces
• Pe bază de fire

În acest articol, veți afla despre Pe bază de fire multitasking sau Multithreading .

Ce este un fir?

Un fir este practic un independent fluxul de execuție. Un singur proces poate consta din mai multe fire. Fiecare fir dintr-un program îndeplinește o anumită sarcină. De exemplu, când jucați un joc, spuneți FIFA pe computerul dvs., jocul în ansamblu este un singur proces , dar este alcătuit din mai multe fire responsabile pentru redarea muzicii, preluarea de informații de la utilizator, rularea sincronă a adversarului etc. Toate acestea sunt fire separate responsabile pentru îndeplinirea acestor sarcini diferite în același program.

Fiecare proces are un fir care rulează întotdeauna. Acesta este firul principal. Acest fir principal creează de fapt obiectele firului copil. Firul copil este, de asemenea, inițiat de firul principal. Vă voi arăta mai departe în acest articol cum să verificați firul de rulare curent.

Deci, cu aceasta, sper că ați înțeles clar ce este un fir. Mai departe, să vedem ce este Multithreading în Python.

Când se folosește Multithreading în Python?

Multithreading-ul este foarte util pentru economisirea timpului și îmbunătățirea performanței, dar nu poate fi aplicat peste tot.
În exemplul FIFA anterior, firul de muzică este independent de firul care îți ia intrarea, iar firul care îți ia intrarea este independent de firul care rulează adversarul tău. Aceste fire rulează independent, deoarece nu sunt interdependente.

Prin urmare, multithreading-ul poate fi utilizat numai atunci când dependența dintre fire individuale nu există.

Acest articol arată în continuare cum puteți realiza Multithreading în Python.

Cum se realizează Multithreading în Python?

Multithreading în Python poate fi realizat prin importul fișierului filetat modul.

Înainte de a importa acest modul, va trebui să îl instalați. Pentru a instala acest lucru pe mediul dvs. anaconda, executați următoarea comandă pe promptul dvs. anaconda:

conda install -c conda-forge tbb

După instalarea cu succes, puteți utiliza oricare dintre următoarele comenzi pentru a importa modulul de filetare:

import filetare din filetare import *

Acum că aveți instalat modulul de filetare, permiteți-ne să mergem mai departe și să facem Multithreading în Python.

Cum se creează fire în Python?

Firele din Python pot fi create în trei moduri:

1. Fără a crea o clasă
2. Prin extinderea clasei Thread
3. Fără a extinde clasa Thread

Fără a crea o clasă

Multithreading în Python poate fi realizat fără a crea și o clasă. Iată un exemplu pentru a demonstra același lucru:

Exemplu:

din threading import * print (current_thread (). getName ()) def mt (): print ('Child Thread') child = Thread (target = mt) child.start () print ('Executând numele thread-ului:', current_thread ( ) .getName ())

Ieșire:

MainThread Child Thread Execută numele firului: MainThread

Ieșirea de mai sus arată că primul fir care este prezent este, firul principal. Acest fir principal creează apoi un fir secundar care execută funcția și apoi instrucțiunea de imprimare finală este executată din nou de firul principal.

Acum să mergem mai departe și să vedem cum să facem Multithreading în python extinzând clasa Thread.

Prin extinderea clasei Thread:

Când o clasă copil este creată prin extinderea clasei Thread, clasa child reprezintă că un fir nou execută o anumită sarcină. La extinderea clasei Thread, clasa copil poate suprascrie doar două metode, adică metoda __init __ () și metoda run (). Nicio altă metodă nu poate fi suprascrisă decât aceste două metode.

Iată un exemplu despre cum să extindeți clasa Thread pentru a crea un thread:

Exemplu:

import threading import timp clasă mythread (threading.Thread): def run (auto): pentru x în intervalul (7): print ('Bună de la copil') a = mythread () a.start () a.join () print („Pa de la”, current_thread (). GetName ())

Ieșire:
Bună de la copil
Bună de la copil
Bună de la copil
Bună de la copil
Bună de la copil
Bună de la copil
Bună de la copil
Pa la MainThread

Exemplul de mai sus arată că clasa myclass moștenește clasa Thread și clasa copil, adică myclass suprascrie metoda run. În mod implicit, primul parametru al oricărei funcții de clasă trebuie să fie auto, care este indicatorul către obiectul curent. Ieșirea arată că firul copil execută metoda run () și firul principal așteaptă finalizarea executării copilului. Acest lucru se datorează funcției join (), care face ca firul principal să aștepte finalizarea copilului.

Această metodă de creare a firelor este cea mai preferată metodă, deoarece este metoda standard. Dar, în cazul în care doriți să creați fire fără a moșteni sau extinde clasa Thread, o puteți face în modul următor.

Fără extinderea clasei Thread

Pentru a crea un thread fără a extinde clasa Thread, puteți face următoarele:
Exemplu:

din threading import * class ex: def myfunc (self): #self necesar ca prim parametru într-o clasă func pentru x în intervalul (7): print ('Copil') myobj = ex () thread1 = Thread (target = myobj. myfunc) thread1.start () thread1.join () print ('gata')

Ieșire:

Copil
Copil
Copil
Copil
Copil
Copil
Copil
Terminat

Avantajele utilizării filetării

Multithreading are multe avantaje, dintre care unele sunt următoarele:

• O mai bună utilizare a resurselor
• Simplifică codul
• Permite apariția simultană și paralelă a diferitelor sarcini
• Reduce consumul de timp sau timpul de răspuns, crescând astfel performanța.

Iată un exemplu pentru a verifica cât durează un cod pentru a se executa cu și fără multithreading în python:

ce este tipărit în python

 Exemplu: 

timp de import def sqr (n): pentru x în n: time.sleep (1) x% 2 def cub (n): pentru x în n: time.sleep (1) x% 3 n = [1,2,3 , 4,5,6,7,8] s = time.time () sqr (n) cub (n) e = time.time () print (es)

Ieșire:

16.042309284210205

Cele de mai sus reprezintă timpul de ieșire necesar pentru a executa programul fără a utiliza fire. Acum, să folosim fire și să vedem ce se întâmplă cu același program:

Exemplu:

import filetare din filetare import * import timp def sqr (n): pentru x în n: time.sleep (1) print ('Rămâne după împărțirea la 2', x% 2) def cub (n): pentru x în n: time.sleep (1) print ('Rest după împărțirea la 3', x% 3) n = [1,2,3,4,5,6,7,8] start = time.time () t1 = Thread ( target = sqr, args = (n,)) t2 = Thread (target = cub, args = (n,)) t1.start () time.sleep (1) t2.start () t1.join () t2.join () end = time.time () print (end-start)

Rezultatul de mai sus arată clar că timpul necesar când folosim fire este mult mai mic în comparație cu timpul necesar pentru același program pentru a executa fără a utiliza fire.

Sper că sunteți clar cu conceptele acoperite în acest articol legate de Multithreading în Python. Asigurați-vă că exersați cât mai mult posibil, deoarece acesta este unul dintre cele mai importante concepte utilizate în programare.

Ai o întrebare pentru noi? Vă rugăm să o menționați în secțiunea de comentarii a acestui blog „Multithreading în Python” și noi voi reveniți la dvs. cât mai curând posibil.

Pentru a obține cunoștințe aprofundate despre Python împreună cu diferitele sale aplicații, vă puteți înscrie pentru live cu suport 24/7 și acces pe viață.