Deadlock and Starvation sa Operating System OS
Ang operating system ay ang pinaka-pangunahing software na tumatakbo sa isang computer. Ito ay responsable para sa pamamahala ng memorya at proseso ng computer, pati na rin ang pagsasara ng mga detalye ng hardware mula sa mga programang application na gumagamit nito. Tinitiyak din ng isang operating system ng computer ang makatarungang paglalaan ng mga mapagkukunan sa mga gumagamit at programa kumpara sa pantay na pamamahagi sa mga proseso. Ang isang makatarungang sistema ng pag-iskedyul ay nagpapahintulot sa isang proseso na gumamit ng CPU habang ang isa ay naghihintay sa queue. Bilang isang resulta ang bawat thread ay nakakakuha ng sapat na access sa limitadong mapagkukunan na pumipigil sa dalawang pinakakaraniwang mga kondisyon na maantala ang proseso kung hindi man: Deadlock and Starvation. Ang parehong may kaugnayan konsepto kung saan ang mga proseso ay walang access sa mga mapagkukunan. Itinatampok ng artikulong ito ang ilang mga pangunahing punto ng paghahambing sa dalawa sa iba't ibang larangan.
Ano ang Deadlock?
Ang deadlock ay isang kondisyon kung saan ang isang hanay ng mga thread ay hinarangan dahil ang bawat proseso na may hawak na isang mapagkukunan ay sinusubukang i-access ang ilang mga iba pang mga mapagkukunan na gaganapin sa pamamagitan ng isa pang proseso huli pumipigil sa isang makatarungang pag-iiskedyul ng sistema. Isang sitwasyon ng deadlock ang nanggagaling kapag ang sumusunod na apat na kondisyon ay tapat: Ang pagbubukod ng Mutual ay nangangahulugan lamang ng isang proseso na makakapag-access ng isang mapagkukunan nang sabay-sabay; Walang kondisyon sa preemption nangangahulugan na ang isang mapagkukunan ay maaari lamang na palabasin kusang-loob sa pamamagitan ng proseso na may hawak na mapagkukunan; Hold & wait ay nangangahulugan na ang isang proseso na may hawak na mapagkukunan ay maaaring humiling ng karagdagang mga mapagkukunan na hinahawakan ng iba pang mga proseso at Ang paghihintay ng Circular ay nangangahulugang dalawa o higit pang mga proseso ang natigil sa isang pabilog na kadena na naghihintay para sa bawat proseso upang palabasin ang kani-kanilang mga mapagkukunan.
Ano ang Pagkabigo?
Ang pagkagutom ay isang kundisyon na lumilitaw kapag ang isang proseso ay napupunta sa panahon ng paghihintay nang walang katapusan bilang isang mababang proseso ng priyoridad na hindi makakakuha ng pagkakataong ma-access ang mapagkukunan dahil sa isang patuloy na daloy ng mga proseso ng mataas na priyoridad sa pag-access sa parehong mapagkukunan. Ito ay isang problema sa pamamahala ng mapagkukunan dahil ang isang proseso ay tinanggihan ang pag-access sa mapagkukunan na nangangailangan nito sa gayon ay itulak ang proseso sa isang walang katapusang panahon ng paghihintay. Ito ay nangyayari dahil ang mapagkukunan na kailangan nito ay hindi kailanman inilalaan sa proseso na nagdudulot ng proseso na magutom sa mga mapagkukunan, kaya ang pangalan. Ang pinakamahusay na paraan upang maiwasan ang gutom ay ang paggamit ng pamamaraan ng pag-iipon na dahan-dahang pinatataas ang priyoridad ng mga proseso na nasa panahon ng paghihintay para sa isang mahabang panahon upang matiyak ang isang makatarungang sistema ng pag-iiskedyul.
Pagkakaiba sa pagitan ng Deadlock at Starvation sa OS
Parehong kalokohan at gutom ay kaugnay na mga konsepto na pumipigil sa isang makatarungang pag-iiskedyul ng sistema kung saan ang mga proseso ay naharang mula sa pagkuha ng access sa mga mapagkukunan. Ang deadlock, tulad ng pangalan ay nagmumungkahi, ay tumutukoy sa isang kundisyon kung saan ang isang hanay ng mga thread o proseso ay na-block dahil ang bawat proseso ay naghihintay upang makakuha ng isang mapagkukunan na gaganapin sa pamamagitan ng isa pang proseso sa gayon na nagreresulta sa isang sitwasyon ng deadlock kung saan ang mga programa ay tumigil sa pag-andar. Ang gutom, sa kabilang banda, ay na-trigger ng isang hindi pagkakasundo na nagiging sanhi ng isang proseso sa freeze dahil ang isang mababang proseso ng priority ay tinanggihan ang access sa isang mapagkukunan na inilalaan sa isang mataas na proseso ng priority.
Ang isang deadlock ay tumutukoy sa isang partikular na kondisyon na nangyayari kapag ang isang thread o isang proseso ay napupunta sa isang panahon ng paghihintay dahil ang kahilingan ng system na hiniling nito ay gaganapin sa pamamagitan ng isa pang proseso, na naghihintay naman ng isa pang proseso upang palabasin ang mapagkukunan nito sa gayon paglikha ng isang hindi pagkakasundo. Ito ay sanhi ng mahinang paggamit ng mapagkukunan. Ang kagutuman ay isang hindi tiyak na kondisyon na pagpapaliban kung saan ang isang mababang proseso ng prayoridad ay tinanggihan ang pag-access sa mga mapagkukunang kailangan nito dahil ang mga mapagkukunan ay inilalaan sa isa pang mataas na proseso ng priyoridad. Ito ay isang problema sa pangangasiwa ng mapagkukunan na pinipilit ang sistema na maglaan ng mga mapagkukunan sa mga proseso lamang ng mataas na priyoridad.
Ang deadlock ay ang tunay na anyo ng gutom na sanhi kapag ang sumusunod na apat na mga kondisyon ay nagaganap nang sabay-sabay: Pagbubukod ng Mutual, Walang Pahihintulutan, Hold & Wait, at Circular Wait. Ang isang kondisyon ng deadlock ay nangyayari lamang sa mga sistema kung saan ang lahat ng apat na kondisyon ay tapat. Ang kagutuman ay nangyayari batay sa iba't ibang mga kondisyon tulad ng kapag walang sapat na mapagkukunan upang pumunta sa paligid at prayoridad ng mga proseso ay nagsisimula sa pagkuha ng mas mababa o kapag ang mga proseso simulan ang handing ng mga mapagkukunan sa iba pang mga proseso nang walang kontrol. Kung ang isang proseso ng mababang prayoridad ay humiling ng mapagkukunan na nakalaan para sa mga pinakamataas na proseso ng priyoridad, ang proseso ay bumababa nang husto. Ang kagutuman ay nangyayari rin kapag ang mga mapagkukunan ay inilalaan na arbitrarily na nagdudulot ng mga proseso upang maghintay para sa isang mas matagal na panahon.
Maaaring mapigilan ang pagkagalit sa pamamagitan ng paggamit ng wastong algorithm sa pag-iskedyul na may priority queue na sa katunayan ay gumagamit din ng aging technique - isang iskedyul na pamamaraan na nagdaragdag ng aging factor sa prayoridad ng bawat kahilingan na nangangahulugan na pinatataas nito ang antas ng priyoridad ng mababang proseso ng priyoridad na naghihintay sa mahabang panahon. Ang pagbibigay ng mas maraming mapagkukunan sa mga programa ay dapat na maiwasan ang patuloy na pagsisikip ng mga mapagkukunan. Upang maiwasan ang sistema sa pagpunta sa isang hindi pagkakasundo, mga proseso ay dapat na tinanggihan ng access sa isa o higit pang mga mapagkukunan habang sabay na naghihintay para sa iba at isa lamang na proseso ang dapat pahintulutan na mag-access ng isang mapagkukunan nang sabay-sabay.
Deadlock vs Starvation: Chart ng Paghahambing
Buod ng Deadlock VS. Gutom
Parehong hindi pagkakasundo at gutom ay kaugnay na mga konsepto sa multiprocessing operating system o mga sistema ng ibinahagi na nagiging sanhi ng isa o higit pang mga thread o proseso upang mapagmataas sa paghihintay para sa mga mapagkukunan na kailangan nila. Ang deadlock ay isang sitwasyon na kung saan ang isa o higit pang mga proseso ay humiling ng access sa parehong mapagkukunan na nagiging sanhi ng proseso sa pag-freeze, samantalang ang gutom ay sanhi ng pagkawala ng hadlang na nagtutulak sa proseso sa isang hindi tiyak na pagpapaliban estado dahil ang mga proseso ay tinanggihan ang access sa isang mapagkukunan na hawak ng isang mataas na proseso ng priority at kailangang maghintay magpakailanman.
