Semaphore vs Monitor
Ang Semaphore ay isang istraktura ng data na ginagamit upang matiyak na hindi maa-access ng maraming proseso ang isang karaniwang mapagkukunan o isang kritikal na seksyon sa parehong oras, sa mga parallel programming environment. Ginagamit ang mga semaphore upang maiwasan ang mga dead lock at kundisyon ng lahi. Ang monitor ay isang programming language construct na ginagamit din para maiwasan ang maraming proseso na nag-a-access sa isang karaniwang mapagkukunan nang sabay-sabay kaya ginagarantiyahan ang mutual exclusion. Gumagamit ang mga monitor ng mga conditional variable para makamit ang gawaing ito.
Ano ang Semaphore?
Ang Semaphore ay isang istraktura ng data na ginagamit upang magbigay ng kapwa pagbubukod sa mga kritikal na seksyon. Pangunahing sinusuportahan ng mga semaphor ang dalawang operasyon na tinatawag na wait (historikal na kilala bilang P) at signal (historikal na kilala bilang V). Hinaharangan ng operasyon ng paghihintay ang isang proseso hanggang sa mabuksan ang semaphore at pinapayagan ng operasyon ng signal ang isa pang proseso (thread) na pumasok. Ang bawat semaphore ay nauugnay sa isang pila ng mga proseso ng paghihintay. Kapag ang operasyon ng paghihintay ay tinawag ng isang thread, kung ang semaphore ay bukas, ang thread ay maaaring magpatuloy. Kung ang semaphore ay sarado kapag ang operasyon ng paghihintay ay tinawag ng isang thread, ang thread ay naharang at kailangan itong maghintay sa pila. Ang operasyon ng signal ay nagbubukas ng isang semaphore at kung mayroon nang isang thread na naghihintay sa pila, ang prosesong iyon ay pinapayagang magpatuloy at kung walang mga thread na naghihintay sa queue ang signal ay naaalala para sa susunod na mga thread. Mayroong dalawang uri ng semaphores na tinatawag na mutex semaphores at counting semaphores. Ang mga mutex semaphores ay nagbibigay-daan sa isang solong pag-access sa isang mapagkukunan at ang pagbibilang ng mga semaphor ay nagbibigay-daan sa maraming mga thread na ma-access ang isang mapagkukunan (na mayroong ilang mga yunit na magagamit).
Ano ang Monitor?
Ang monitor ay isang programming language construct na ginagamit upang kontrolin ang access sa nakabahaging data. Pinapaloob ng mga monitor ang mga nakabahaging istruktura ng data, mga pamamaraan (na gumagana sa mga istruktura ng nakabahaging data) at pag-synchronize sa pagitan ng mga sabay-sabay na invocation ng procedure. Tinitiyak ng isang monitor na ang data nito ay hindi nahaharap sa mga hindi nakabalangkas na pag-access at ginagarantiyahan na ang mga tread (na nag-a-access sa data ng monitor sa pamamagitan ng mga pamamaraan nito) ay nakikipag-ugnayan sa isang lehitimong paraan. Ginagarantiyahan ng monitor ang mutual exclusion sa pamamagitan ng pagpapahintulot sa isang thread lang na magsagawa ng anumang pamamaraan ng monitor sa isang partikular na oras. Kung ang isa pang thread ay sumusubok na mag-invoke ng isang pamamaraan sa monitor, habang ang isang thread ay nagsasagawa na ng isang pamamaraan sa monitor, pagkatapos ay ang pangalawang pamamaraan ay naharang at ito ay kailangang maghintay sa pila. Mayroong dalawang uri ng monitor na pinangalanang Hoare monitor at Mesa monitor. Pangunahing naiiba ang mga ito sa kanilang semantika sa pag-iiskedyul.
Ano ang pagkakaiba ng Semaphore at Monitor?
Kahit na parehong ginagamit ang mga semaphor at monitor para makamit ang mutual na pagbubukod sa mga parallel programming environment, naiiba ang mga ito sa mga diskarteng ginamit para makamit ang gawaing ito. Sa mga monitor, ang code na ginagamit para makamit ang mutual exclusion ay nasa iisang lugar at mas structured, habang ang code para sa mga semaphore ay ipinamamahagi bilang wait at signal function na tawag. Gayundin, napakadaling magkamali kapag nagpapatupad ng mga semaphore, habang napakaliit ng pagkakataong magkamali kapag nagpapatupad ng mga monitor. Dagdag pa, gumagamit ang mga monitor ng mga variable ng kundisyon, habang ang mga semaphor ay hindi.
