Multithreading este conceptul de a rula mai multe fire de execuție într-un singur program. Este o caracteristică foarte utilă în limbaje de programare precum C++, deoarece ne permite să efectuăm mai multe operații simultan. În C++, multithreading poate fi realizat prin intermediul
Multithreading este la fel ca multitasking. Înseamnă că două sau mai multe fire rulează simultan. Într-un astfel de program, fiecare componentă este denumită un fir de execuție, iar fiecare fir de execuție specifică o cale unică de execuție. Nu există suport încorporat pentru multifile programe anterioare C++ 11. Această caracteristică este în schimb furnizată în totalitate de sistemul de operare.
Multithreading poate fi denumită și împărțirea unui program în fire mai mici care se execută concomitent. Clasa de fire, care este folosită pentru multithreading în C++, vă permite să construiți numeroase fire și să gestionați execuția acestora.
Creați fire în C++
Pentru a crea un fir în C++, folosim std::thread clasa, care este inclusă în biblioteca de fire încorporată. A apelabil este furnizat ca argument constructorului unui obiect al clasei std::thread pentru a genera un nou thread. Codul care este executat atunci când un fir de execuție este activ este cunoscut ca apelabil . Când construim a std::thread obiect, se stabilește un fir nou, care determină codul furnizat de apelabil a fi condus. Apelabil poate fi definit folosind aceste trei metode.
Metoda 1: Indicator de funcție
Apelabil funcțiile care utilizează un indicator de funcție pot fi definite astfel.
void function_call ( parametrii )
Când funcția a fost construită, un obiect thread care conține funcția este generat după cum urmează:
std::thread thread_obj ( function_call, parametri ) ;
Metoda 2: Obiectul funcției
În timp ce folosim obiectul funcție, profităm de ideea supraîncărcării operatorului. Codul care trebuie rulat în timp ce firul de execuție este format este conținut în funcția supraîncărcată.
clasa Object_class {operator nul ( ) ( parametrii )
{
// cod de executat
}
} ;
std::thread thread_object ( Clasa_obiect ( ) , parametrii )
Metoda 3: Expresia Lambda
Apelabil funcțiile care utilizează o expresie lambda pot fi definite astfel.
auto f = [ ] ( parametrii ) {// cod de executat
} ;
std::thread thread_object ( f, parametri ) ;
Exemplu de Multithreading în C++
#include#include
folosind namespace std;
void func_thread ( int N )
{
pentru ( int i = 0 ; i < N; i++ ) {
cout << „Thread 1 :: callable => Folosind un indicator de funcție \n ' ;
}
}
clasa thread_obj {
public:
operator nul ( ) ( int n ) {
pentru ( int i = 0 ; i < n; i++ )
cout << „Thread 2 :: callable => Utilizarea unui obiect funcție \n ' ;
}
} ;
int principal ( )
{
auto f = [ ] ( int n ) {
pentru ( int i = 0 ; i < n; i++ )
cout << „Thread 3 :: callable => Folosind o expresie lambda \n ' ;
} ;
firul th1 ( func_thread, 2 ) ;
firul th2 ( fir_obj ( ) , 2 ) ;
firul th3 ( f, 2 ) ;
th1.ună ( ) ;
th2.ună ( ) ;
th3.ună ( ) ;
întoarcere 0 ;
}
În codul de mai sus, am dezvoltat trei fire cu trei separate apelabile -un indicator de funcție, un obiect și o expresie lambda. Fiecare fir este pornit ca două instanțe separate. Trei fire sunt active simultan și separat, așa cum este indicat în rezultat.
Ieșire
Avantajele și dezavantajele Multithreading-ului
Mai multă muncă se poate face mai rapid datorită multithreading . Acest lucru se datorează faptului că permite numeroaselor fire să efectueze diverse sarcini simultan. Multithreading permite programatorilor să facă activități în rețea, să proceseze fotografii sau videoclipuri și să efectueze calcule complicate fără a încetini restul aplicației. Multithreading ajută la a face interfețele cu utilizatorul mai receptive. Prin rularea codului care schimbă ecranul într-un fir separat, firul UI este păstrat liber pentru a efectua alte sarcini, cum ar fi răspunsul la intrarea utilizatorului. Acest lucru are ca rezultat interfețe de utilizator mai fluide și mai rapide.
Cu toate acestea, există anumite limitări ale utilizării multithreading . Una dintre provocările cheie atunci când lucrați cu multifile programele este evitarea condițiilor de cursă. O condiție de cursă este o situație în care două sau mai multe fire de execuție încearcă să acceseze aceeași resursă partajată în același timp, ceea ce duce la un comportament imprevizibil. Pentru a evita condițiile de cursă, dezvoltatorii folosesc tehnici de sincronizare, cum ar fi mutexuri, semafore și bariere.
Concluzie
Multithreading în C++ este un concept puternic care permite dezvoltatorilor să creeze programe care pot efectua mai multe sarcini simultan. Folosind clasa de fire furnizată de bibliotecă, dezvoltatorii pot crea, gestiona și controla mai multe fire. Multithreading poate fi folosit pentru a îmbunătăți performanța, a crește capacitatea de răspuns și a depăși limitările resurselor sistemului. Cu toate acestea, din cauza provocărilor pe care le implică lucrul cu multifile programe, dezvoltatorii trebuie să fie atenți și să folosească tehnici de sincronizare adecvate pentru a evita condițiile de cursă.