C++ este cunoscut a fi unul dintre cele mai rapide limbaje de programare, cu performanțe bune, precizie ridicată și un sistem adecvat de gestionare a memoriei. Acest limbaj de programare acceptă și execuția concomitentă a mai multor fire de execuție cu partajarea mai multor resurse între ele. În multithreading, firul de execuție este doar pentru a efectua operația de citire care nu face probleme, deoarece firul de execuție nu este afectat de ceea ce fac celelalte fire în acel moment. Dar dacă aceste fire ar trebui să împartă resursele între ele, un fir poate modifica datele în acel moment, ceea ce face problema. Pentru a face față acestei probleme, avem C++ „Mutex” care împiedică accesul mai multor resurse către codul/obiectul nostru prin furnizarea de sincronizare care afirmă că accesul la obiect/cod poate fi furnizat doar unui fir de execuție la un moment dat, astfel încât multiplu de fire să nu poată accesa acel obiect simultan.
Procedură:
Vom afla cum putem opri accesul mai multor fire de execuție la un obiect în același timp folosind blocarea mutex. Vom vorbi despre sintaxa blocării mutex, ce este threadingul multiplu și cum putem face față problemelor cauzate de blocarea mutexului folosind blocarea mutex. Apoi, vom lua un exemplu de threading multiplu și vom implementa blocarea mutex pe ele.
Sintaxă:
Dacă vrem să aflăm cum putem implementa blocarea mutex, astfel încât să putem preveni accesul mai multor fire simultan către obiectul sau codul nostru, putem folosi următoarea sintaxă:
$ std :: mutex mut_x
$mut_x. Lacăt ( ) ;
Void func_name ( ) {
$ // codul pe care vrem să-l ascundem de la mai multe fire ar fi scris aici
$mut_x. se deblochează ( ) ;
}
Vom folosi acum această sintaxă în exemplul fals și în pseudocodul (pe care nu îl putem rula doar așa cum este în editorul de cod) pentru a vă anunța cum putem folosi exact această sintaxă, așa cum se menționează în cele ce urmează:
$ std :: mutex mut_x
Blocarea golului ( ) {
$mut_x. Lacăt ( ) ;
$ std :: cout << 'Buna ziua' ;
$mut_x. se deblochează ( ) ;
}
Exemplu:
În acest exemplu, să încercăm mai întâi să creăm operația multithread și apoi să înconjurăm această operație cu blocare și deblocare mutex pentru a asigura sincronizarea operației cu codul sau obiectul creat. Mutex se ocupă de condițiile de cursă, care sunt valori destul de imprevizibile și depind de comutarea firelor care sunt conștiente de timp. Pentru a implementa exemplul pentru mutex, mai întâi trebuie să importam bibliotecile importante și necesare din depozite. Bibliotecile necesare sunt:
$ # include
$ # include
$ # include
Biblioteca „iostream” ne oferă o funcție pentru a afișa datele ca Cout, a citi datele ca Cin și a termina declarația ca endl. Folosim biblioteca „thread” pentru a utiliza programele sau funcțiile din fire. Biblioteca „mutex” ne permite să implementăm atât blocarea mutex, cât și deblocarea în cod. Folosim „# include” deoarece aceasta permite toate programele legate de biblioteca incluse în cod.
Acum, după ce s-a terminat pasul anterior, definim clasa mutex sau o variabilă globală pentru mutex folosind std. Apoi, creăm o funcție pentru blocarea și deblocarea mutex pe care am putea-o apela ulterior în cod. În acest exemplu, denumim această funcție ca bloc. În corpul funcției de bloc, apelăm mai întâi „mutex.lock()” și începem să scriem logica codului.
Mutex.lock() interzice accesul celorlalte fire de execuție pentru a ajunge la obiectul sau codul nostru creat, astfel încât doar un fir de execuție să poată citi obiectul nostru la un moment dat. În logică, rulăm o buclă for care rulează pe indexul de la 0 la 9. Afișăm valorile în buclă. Odată ce această logică este creată în blocarea mutex după terminarea operației sau după ieșirea din logică, numim metoda „mutex.unlock()”. Acest apel de metodă ne permite să deblocăm obiectul creat de la blocarea mutex, deoarece accesul obiectului la un singur fir a fost furnizat mai devreme și odată ce operațiunea pe acel obiect este efectuată de un fir de execuție la un moment dat. Acum vrem ca și celelalte fire să acceseze acel obiect sau cod. În caz contrar, codul nostru se mută în situația „deadlock”, ceea ce face ca obiectul creat cu mutex să rămână în situația blocat pentru totdeauna și niciun alt fir nu ar putea accesa acel obiect. Prin urmare, o operație incompletă continuă să se execute. După aceasta, ieșim din funcția de bloc și trecem la principal.
În principal, pur și simplu afișăm mutex-ul creat prin crearea celor trei fire folosind „std :: thread thread_name (apelând funcția de bloc deja creată aici în care am creat mutexul)” cu numele thread1, thread2 și thread3 etc. În acest fel, cele trei fire sunt create. Apoi unim aceste trei fire de execuție pentru a fi executate simultan apelând „nume_fir. metoda join ()”. Și apoi, returnăm valoarea egală cu zero. Explicația menționată anterior a exemplului este implementată sub forma codului care poate fi prezentat în următoarea figură:
În ieșirea codului, putem vedea execuția și afișarea tuturor celor trei fire unul câte unul. Putem vedea chiar dacă aplicația noastră se încadrează în categoria multithreading. Totuși, niciunul dintre fire nu a suprascris sau modificat datele și a partajat resursa modificată din cauza implementării mutex-ului „blocului funcțional”.
Concluzie
Acest ghid oferă o explicație detaliată a conceptului de funcție mutex folosită în C++. Am discutat care sunt aplicațiile multithreading, ce probleme trebuie să întâlnim în aplicațiile multithreading și de ce trebuie să implementăm mutex-ul pentru aplicațiile multithreading. Am discutat apoi despre sintaxa pentru mutex cu exemplul fals folosind pseudo-codul. Apoi, am implementat un exemplu complet pe aplicațiile multithreading cu mutex pe studioul vizual C++.