Semaphore vs Mutex
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. Ginagamit din ang Mutex (Mutual Exclusion Object) upang maiwasan ang pag-access sa isang karaniwang mapagkukunan nang sabay-sabay ng ilang magkakasabay na proseso.
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. Binibigyang-daan ng mga mutex semaphore ang 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 Mutex?
Kapag nagsimula ang isang computer application, gagawa ito ng mutex at ikakabit ito sa isang mapagkukunan. Kapag ang mapagkukunan ay ginamit ng isang thread, ito ay naka-lock at hindi magagamit ng ibang mga thread. Kung gusto ng isa pang thread na gumamit ng parehong mapagkukunan, kailangan nitong humiling. Pagkatapos ang thread na iyon ay ilalagay sa isang queue hanggang sa matapos ang unang thread kasama ang mapagkukunan. Kapag natapos na ang unang thread sa resource, aalisin ang lock at ang thread na naghihintay sa queue ay makakakuha ng access sa resource. Kung mayroong maraming mga thread na naghihintay sa pila, binibigyan sila ng access sa isang umiikot na batayan. Sa praktikal, kapag pinapalitan ng mutex ang pag-access sa isang mapagkukunan sa pagitan ng ilang mga thread, makikita ito habang ang maraming mga thread ay gumagamit ng isang mapagkukunan sa parehong oras. Ngunit sa loob, isang thread lang ang nag-a-access sa mapagkukunan sa isang partikular na oras.
Ano ang pagkakaiba ng Semaphore at Mutex?
Kahit na, parehong ginagamit ang mga semaphores at mutex na object para makamit ang mutual exclusion sa parallel programming environment, mayroon silang ilang pagkakaiba. Ang isang bagay na mutex ay nagbibigay-daan lamang sa isang thread na kumonsumo ng isang mapagkukunan o isang kritikal na seksyon, samantalang ang mga semaphor ay nagbibigay-daan sa isang pinaghihigpitang bilang ng mga sabay-sabay na pag-access sa isang mapagkukunan (sa ilalim ng maximum na pinapayagang numero). Sa mga mutex object, ang ibang mga thread na gustong mag-access sa resource ay kailangang maghintay sa isang queue, hanggang sa ang kasalukuyang thread ay matapos gamit ang resource.
