Ang POSIX ay tumutukoy sa Portable Interface ng OS, na isang pamantayan sa IEEE, na binuo upang matulungan ang kakayahang dalhin ng iba't ibang mga application. Ang POSIX ay isang pagsisikap na bumuo ng isang karaniwang pamantayan ng UNIX sa pamamagitan ng pakikipagtulungan ng mga vendor. Gagawin nitong mas madali ang pag-port ng mga app sa mga platform ng hardware kung epektibo ang mga ito. Ang Hewlett-Packard ay isinasama ang POSIX sa kanyang lisensyadong MPE / iX OS bersyon 5.0 at bersyon ng HP / UXX 10.0, ayon sa pagkakabanggit (ang UNIX).
Ang pamantayan ng POSIX ay may higit sa sampung bahagi, gayunpaman, ang dalawa ay madaling makuha. Inilalarawan ng POSIX.1 ang mga interface ng C programming (ibig sabihin, isang library ng tawag sa system) para sa mga file, pamamaraan, at mga terminal na I / O. Ang library ng pakete ng C POSIX para sa mga platform ng POSIX ay isang balangkas ng standard na aklatan ng C. Ito ay itinatag sa parehong oras tulad ng karaniwang ANSI C. Upang gawing sumusunod ang POSIX sa pamantayan ng C, maraming mga pagtatangka ang nagawa. Nagbibigay ang POSIX ng mga karagdagang tampok sa mga ipinatupad sa pamantayan ng C.
POSIX Semaphores
Ang isang semaphore ay isang istraktura ng data na madalas na ginagamit para sa pagsabay ng mga proseso at pagtulong sa mga thread nang hindi nakikipag-ugnayan ang isa't isa upang gumana nang magkasama. Ang interface para sa semaphores ay tinukoy ng pamantayan ng POSIX. Hindi ito bahagi ng Pthreads. Gayunpaman, ang karamihan sa mga UNIX na sumusuporta sa mga Pthread kahit na nagbibigay ng mga semaphore. Sa mga framework na tulad ng Unix, tulad ng Linux, pinagsasama ang mga semaphore ng mga queues ng mensahe at karaniwang memorya sa ilalim ng mga serbisyo ng Interprocess Communication (IPC). Ang mas matandang framework V semaphores at ang modernong POSIX semaphores ay nagiging dalawang uri ng semaphores. Ang pagtawag sa POSIX Semaphore ay mas madali kaysa sa mga tawag sa System V Semaphore. Bagaman, mas madaling makuha ang mga semaphore ng System V, lalo na sa mga naunang platform na tulad ng Unix. Mayroong pangangailangan upang ikonekta ang mga programa gamit ang POSIX semaphores sa Pthread library. Titingnan namin ang mga POSIX semaphore sa artikulong ito.
Bakit POSIX Semaphores?
Mayroong isang malaking isyu sa paligid ng mga thread, na kondisyon ng lahi. Ito ay isang pangyayari kung saan ang dalawang mga thread ay naghahangad na makakuha at baguhin ang parehong impormasyon, sa gayong paraan ay magkasalungat ito. Upang maiwasan ang isang kundisyon ng lahi, matagal na kaming gumagamit ng mga semaphore.
Ang mga semaphore ay magagamit sa 2 uri:
Binary Semaphore :
Kinikilala din ito bilang isang mutex lock. Magkakaroon lamang ito ng dalawang posibleng halaga, 0 at 1. Ang halaga ay isisimulang bilang 1. Ginagamit ito upang ipatupad ang maraming proseso upang malutas ang malubhang isyu sa seksyon.
Nagbibilang ng Semaphore :
Ang laki nito ay maaaring magkakaiba sa isang walang limitasyong domain. Ginagamit ito upang magkaroon ng awtoridad sa pag-access sa maraming mapagkukunang halimbawa.
Ang balangkas ng Linux POSIX ay may isinamang Semaphore repository. Upang magamit ito, dapat nating:
- Magdagdag ng semaphore.h
- Pile up ang code sa pamamagitan ng pagkonekta sa -lpthread -lrt.
Halos lahat ng mga pamamaraan at form ng POSIX Semaphore ay prototyped o tinukoy sa 'Semaphore.h'. Gagamitin namin ang Semaphore upang ilarawan ang isang entity o object bilang:
>>sem_t sem_name;Narito ang iba't ibang mga pagpapaandar na gagamitin namin sa POSIX Semaphore.
Sem_init
Upang simulan ang isang semaphore, kailangan mong gamitin ang sem_init na pamamaraan. Sa pagpapaandar na ito, ang sem ay tumutugma sa isang inisyal na bagay na semaphore. Ang Pshared ay isang banner o flag na tumutukoy kung ang semaphore ay maaaring ibahagi sa isang forked () na pamamaraan o hindi. Ang mga nakabahaging semaphore ay hindi kasalukuyang naka-brace ng LinuxThreads. Ang halaga ng argument ay ang panimulang halaga kung saan naayos ang semaphore.
>> intsem_init(sem_t*sem, intpshared, hindi pinirmahan inthalaga);Sem_wait
Gagamitin namin ang sem-wait na paraan upang hawakan / i-lock ang isang semaphore o hintayin ito. Kung ang semaphore ay binigyan ng isang negatibong halaga, pagkatapos ang pag-ikot ng tawag ay awtomatikong mai-block. Tuwing anumang iba pang mga thread na tumawag sa sem_post, ang isa sa mga naka-baradong proseso ay gumising.
>> intsem_wait(sem_t*sem);Sem_post
Gagamitin namin ang sem_post na paraan upang madagdagan ang halaga ng isang semaphore. Sa pagtawag, madaragdag ng sem_post ang halaga, at gumising ang isa sa mga naka-barado o naghihintay na proseso.
>> intsem_post(sem_t*sem);Sem_getvalue
Kung nais mong malaman tungkol sa halaga ng isang semaphore, kailangan mong gamitin ang pagpapaandar sa ibaba sem_getvalue. Makukuha nito ang kasalukuyang halaga ng semaphore at mailalagay sa patutunguhang itinuro ng valp.
>>Int sem_getvalue(sem_t*sem, int *tuta);Sem_destroy
Dapat ay gumagamit ka ng sem_destroy na pamamaraan kung nais mong sirain ang semaphore. Kung magpapatuloy ang pagkamatay ng semaphore, walang thread na maghihintay sa semaphore.
>>Int sem_destroy(sem_t*sem);I-install ang GCC Utility
Upang maipon ang POSIX Semaphore C code, dapat ay naka-install ang utility na gcc sa iyong Linux system. Para sa hangaring ito, buksan ang iyong terminal ng utos at subukan ang utos sa ibaba.
$sudo apt-get install gcc 
Kumpirmahin ang iyong aksyon sa pamamagitan ng pagpindot AT .
Pagpapatupad ng POSIX Semaphore na may C programa sa Ubuntu
Sa simula pa lang, kailangan mong lumikha ng isang bagong file na may isang .cpp extension sa Ubuntu 20.04 system. Para dito, kailangan mong mag-navigate patungo sa iyong Home Directory at lumikha ng isang bagong walang laman na file na pinangalanang new.cpp. Maaari mo rin itong likhain gamit ang touch command sa iyong terminal ng utos.
Maaari mong makita na ang new.cpp file ay nilikha sa Home Directory.
Matapos ang paglikha ng .cpp file, buksan ito bilang isang Text Editor sa iyong Linux system at isulat ang code sa ibaba sa file na ito. Pagkatapos nito, i-save at isara ito.
Isagawa ang POSIX Semaphore C Program Sa Ubuntu 20.04
Buksan ang iyong terminal Sa Ubuntu 20.04 at ipatupad ang ibaba gcc command na sinusundan ng filename.
$gccfilename.c –lpthread –lrt 
Mayroong 2 mga thread na nabuo, ang isa ay nabuo pagkatapos ng 2 segundo ng isa pa. Matapos matanggap ang bolt, ang pinakaunang thread ay natutulog ng 4 na segundo. Kaya, pagkatapos na ito ay tinawag, ang pangalawang thread ay hindi direktang sasali, at lilitaw ito 4-2 = 2 segundo matapos itong tawagin. Narito ang output:
Kung hindi namin ginamit ang semaphore, ayon sa paglipat ng konteksto, ang resulta ay maaaring tulad ng naobserbahan:
Konklusyon
Sa gabay na ito, isang detalyadong pangkalahatang-ideya ng paggamit ng POSIXSemaphore na may C na programa sa Ubuntu 20 ay ibinigay. Sa pamamagitan lamang ng paggamit ng POSIX o Pthread library sa buong tiyak na C code, ang POSIX Semaphore ay maaaring madaling gamitin upang maiwasan ang mga kondisyon ng lahi sa panahon ng pag-coding.