Ang C ++ ay kilala bilang isa sa pinakamabilis na programming language na may mahusay na pagganap, mataas na katumpakan, at isang sapat na sistema ng pamamahala ng memorya. Sinusuportahan din ng programming language na ito ang sabay-sabay na pagpapatupad ng maraming mga thread na may pagbabahagi ng maraming mapagkukunan sa pagitan ng mga ito. Sa multithreading, ang thread ay para lamang gawin ang read operation na walang mga isyu dahil ang thread ay hindi maaapektuhan ng kung ano ang ginagawa ng ibang mga thread sa oras na iyon. Ngunit kung ang mga thread na ito ay kailangang magbahagi ng mga mapagkukunan sa pagitan nila, maaaring baguhin ng isang thread ang data sa oras na iyon na gumagawa ng isyu. Upang harapin ang problemang ito, mayroon kaming C++ na 'Mutex' na pumipigil sa pag-access ng maraming mapagkukunan patungo sa aming code/object sa pamamagitan ng pagbibigay ng synchronization na nagsasaad na ang access sa object/code ay maaaring ibigay sa isang thread lamang sa isang pagkakataon, upang hindi ma-access ng maramihang mga thread ang bagay na iyon nang sabay-sabay.
Pamamaraan:
Malalaman natin kung paano natin mapipigilan ang pag-access ng maraming mga thread sa isang bagay nang sabay-sabay gamit ang mutex lock. Pag-uusapan natin ang tungkol sa syntax ng mutex lock, ano ang multiple threading, at kung paano natin haharapin ang mga isyu na dulot ng multiple threading gamit ang mutex lock. Pagkatapos, kukuha kami ng isang halimbawa ng multiple threading at ipatupad ang mutex lock sa kanila.
Syntax:
Kung gusto naming matutunan kung paano namin maipapatupad ang mutex lock upang maiwasan namin ang pag-access ng maraming thread nang sabay-sabay patungo sa aming object o code, maaari naming gamitin ang sumusunod na syntax:
$ std :: mutex mut_x
$mut_x. kandado ( ) ;
Walang bisa ang function_name ( ) {
$ // code na gusto naming itago mula sa maramihang mga thread ay isusulat dito
$mut_x. nagbubukas ( ) ;
}
Gagamitin na namin ngayon ang syntax na ito sa dummy na halimbawa at sa pseudo code (na hindi lang namin maaaring patakbuhin tulad ng nasa code editor) upang ipaalam sa iyo kung paano namin eksaktong magagamit ang syntax na ito tulad ng nabanggit sa sumusunod:
$ std :: mutex mut_x
Walang laman na bloke ( ) {
$mut_x. kandado ( ) ;
$ std :: cout << 'Kamusta' ;
$mut_x. nagbubukas ( ) ;
}
Halimbawa:
Sa halimbawang ito, subukan muna nating likhain ang multithread operation at pagkatapos ay palibutan ang operasyong ito ng mutex lock at unlock upang maibigay ang pag-synchronize ng operasyon sa code o bagay na ginawa. Ang Mutex ay tumatalakay sa mga kundisyon ng lahi na kung saan ay ang mga halaga na medyo hindi mahuhulaan at sila ay nakadepende sa paglipat ng mga thread na may kamalayan sa oras. Upang ipatupad ang halimbawa para sa mutex, kailangan muna nating i-import ang mahalaga at kinakailangang mga aklatan mula sa mga repositoryo. Ang mga kinakailangang aklatan ay:
$ # isama ang
$ # isama ang
$ # isama ang
Ang 'iostream' library ay nagbibigay sa amin ng isang function upang ipakita ang data bilang Cout, basahin ang data bilang Cin, at wakasan ang pahayag bilang endl. Ginagamit namin ang library ng 'thread' upang magamit ang mga program o function mula sa mga thread. Ang 'mutex' library ay nagpapahintulot sa amin na ipatupad ang parehong mutex lock at unlock sa code. Ginagamit namin ang '# kasama' dahil pinapayagan nito ang lahat ng mga program na nauugnay sa library na kasama sa code.
Ngayon, pagkatapos gawin ang nakaraang hakbang, tinukoy namin ang mutex class o isang global variable para sa mutex gamit ang std. Pagkatapos, gumawa kami ng function para sa mutex lock at unlock na maaari naming tawagan pagkatapos sa code. Sa halimbawang ito, pinangalanan namin ang function na ito bilang block. Sa katawan ng block function, una naming tinatawag ang 'mutex.lock()' at simulan ang pagsulat ng lohika ng code.
Ang mutex.lock() ay tinatanggihan ang pag-access ng iba pang mga thread upang maabot ang aming nilikha na bagay o code upang ang isang thread lamang ang makakabasa ng aming bagay sa isang pagkakataon. Sa lohika, nagpapatakbo kami ng para sa loop na tumatakbo sa index mula 0 hanggang 9. Ipinapakita namin ang mga halaga sa loop. Kapag nalikha ang logic na ito sa mutex lock pagkatapos gawin ang operasyon nito o pagkatapos na lumabas sa logic, tinatawag namin ang 'mutex.unlock()' na paraan. Ang tawag sa pamamaraang ito ay nagbibigay-daan sa amin na i-unlock ang nilikhang bagay mula sa mutex lock dahil ang access ng object sa isang solong thread ay ibinigay nang mas maaga at kapag ang operasyon sa bagay na iyon ay ginawa ng isang thread sa isang pagkakataon. Gusto namin ngayon na ma-access din ng iba pang mga thread ang object o code na iyon. Kung hindi, ang aming code ay gumagalaw sa 'deadlock' na sitwasyon na nagiging sanhi ng nilikha na bagay na may mutex na manatili sa naka-lock na sitwasyon magpakailanman at walang ibang thread ang makaka-access sa bagay na iyon. Samakatuwid, ang isang hindi kumpletong operasyon ay patuloy na isinasagawa. Pagkatapos nito, lumabas kami sa block function at lumipat sa pangunahing.
Sa pangunahin, ipinapakita lang namin ang aming ginawang mutex sa pamamagitan ng paglikha ng tatlong mga thread gamit ang 'std :: thread thread_name (pagtawag sa nalikha nang block function dito kung saan ginawa namin ang mutex)' na may mga pangalan na thread1, thread2, at thread3, atbp Sa ganitong paraan, ang tatlong mga thread ay nilikha. Pagkatapos ay sasali kami sa tatlong mga thread na ito na isasagawa nang sabay-sabay sa pamamagitan ng pagtawag sa 'thread_name. sumali ()” na pamamaraan. At pagkatapos, ibinabalik namin ang halaga na katumbas ng zero. Ang naunang nabanggit na paliwanag ng halimbawa ay ipinatupad sa anyo ng code na maaaring ipakita sa sumusunod na figure:
Sa output ng code, makikita natin ang execution at display ng lahat ng tatlong thread nang paisa-isa. Makikita natin kahit na ang ating aplikasyon ay nasa ilalim ng kategorya ng multithreading. Gayunpaman, wala sa mga thread ang na-overwrit o binago ang data at nagbahagi ng binagong mapagkukunan dahil sa pagpapatupad ng mutex ng 'block ng function'.
Konklusyon
Ang gabay na ito ay nagbibigay ng detalyadong paliwanag ng konsepto ng mutex function na ginamit sa C++. Tinalakay namin kung ano ang mga multithreading application, anong mga problema ang kailangan naming makaharap sa multithreading application, at kung bakit kailangan naming ipatupad ang mutex para sa multithreading application. Pagkatapos ay tinalakay namin ang syntax para sa mutex na may dummy na halimbawa gamit ang pseudo-code. Pagkatapos, nagpatupad kami ng kumpletong halimbawa sa mga multithreading na application na may mutex sa C++ visual studio.