Link1=>
MultiProgramming, Process, Thread, Multithreading … … …..
Microsoft ကသူ. Company စထောင်တော့ DOS ဆိုတာလေးနဲ.စတာ။ ပြောရရင်ခု window တွေမှာပါလာတဲ့ command prompt လိုကောင်မျိုးပေါ့။ သူ.အားနည်းချက်က ဘာလဲဆိုတော့ single programming ပဲရတာ ဆိုချင်တာက OS တခုလုံးမှာ CPU ပေါ်မှာ process တခု program တခုကိုပဲ run လို.ရတာ။ Process ဆိုတာ run နေတဲ့ program ကိုခေါ်တာ။ သူ.မှာဘာတွေပါသလဲဆိုရင် process အတွက် address space တို. virutal memory တို.တခြား process managment လုပ်ဖို.လိုတဲ့ data structure တွေရောပေါ့။ Window မှာ task manager ကနေကြည့်ရင် process ဆိုတဲ့ tab အောက်မှာ ခု run နေတဲ့ process တွေကိုပြတယ်။
ခုနက Single programming ခေတ်တုန်းက memory ကလဲနည်းတယ် အဲ့တော့ process တခုပဲ run လို.ရမယ်။ နောက် hardware တွေ မြင့်လာတယ် memory တွေ လဲပို များလာတယ်။ အဲ့တော့ OS တွေက muti programming ကို support လုပ်လာရတယ်။ Multi programming ဆိုတာ OS မှာ process တခုထက်မက တပြိုင်တည်း (ဒီစကားကလဲ နည်းနည်းရှုပ်တယ် ) run လို.ရအောင်လုပ်ပေးထားတာ။ ဥပမာ ခုဒီစာကိုရိုက်ဖို. ဖေ့ဘုတ်ကို browser နဲ.သုံးလို.ရအောင် browser process တခုကိုသုံးမယ်။ နောက် သီချင်းဖွင့်ထားမယ်ဆိုပါစို. ဒါသည် နောက် process တခု။ အဲ့လိုရတာကို muti programming system လို.ခေါ်တာ။
ဘာလို. Multi Programming ကိုလုပ်ရလဲဆိုတော့ ဥပမာ ခုနက process တွေမှာ CPU task တွေပဲ၇ှိတာမဟုတ်ဘူး။ IO/Device task တွေ ၇ှိတယ်။ အဲ့တော့ IO ကိုဖတ်နေချိန်မှာ အဲ့ process သည် CPU ကို သုံးစရာမလိုဘူး Idle ဖြစ်တယ်။ အဲ့တော့ တခြား process ကိုပေးသုံးလို.ရတယ်။ ပြောချင်တာက computer တခုရဲ. resources တွေကို သေချာသုံးဖြစ်သွားတယ်ပေါ့။ User အတွက်လဲ အဆင်ပြေတာပေါ့။
အဲ့တော့ Process ဆိုတာတော့သိပြီပေါ့။ ဒါဆို thread ကျတော့ရော။ Process switching သည် OS မှာ costly ဖြစ်တယ်။ ဆိုချင်တာက process တခုကနေ တခုကို ပြောင်းဖို.ဆိုရင် လုပ်ရတဲ့ process များတယ်။ တချို. program တွေမှာ process တခုတည်းမှာကိုတင် တပြိုင်တည်းလိုလို လုပ်ရတဲ့ task တွေပါတယ်။ ဥပမာ word မှာ စာရိုက်နေတာကို လက်ခံဖို. processing task တခုလိုမယ်။ တချိန်တည်းမှာ အဲ့ရိုက်ထားတဲ့စာကို စာလုံးပေါင်းစစ်ဖို.က တခြား program task တခုလဲလိုတယ်။ အဲ့တော့ ဘာလုပ်လိုက်လဲဆိုရင် thread ဆိုတာလေး ခွဲလိုက်တယ်။ Thread ဆိုတာ ပြောရရင် process တခုတည်းအောက်ကနေ multiple execution unit လေးတွေ ခွဲထားတာပါပဲ။ အဲ့တော့ စာရိုက်နေတုန်းမှာ spelling checking လုပ်ပေးနိုင်တယ်။ ဘာလို.လဲဆိုတော့ တပြိုင်တည်းနီးပါး run နေလို.။ဒါကို multi threading လို.ခေါ်တယ်။
ခုနက တပြိုင်တည်းနီးပါးလို.ပြောတယ် အဲ့တာကို Concurren လို.သုံးတယ်။ execution unit ၂ ခု thread ၂ ခုသည် တချိန်တည်းမှာ လုပ်နေတာ မဟုတ်ဘူး ။ ဥပမာ CPU က တခုတည်းရှိတယ်ဆိုပါစို. core လဲ မရှိဘူးဆိုပါစို. ခုနက thread ၂ ခုကို တချိန်တည်း လုပ်လို.မရဘူး။ တခုပြီး နောက်တခုကို အလှည့်ပေးရတယ်။ ဒါမျိုးကို time slicing လို.ခေါ်တယ်။ အချိန် အပိုင်းအပိုင်းလေးတွေ ပေးပြီး ရော့ thread 1 run, thread 1 က အကြောင်း အမျိုးမျိုးကြောင့် ဥပမာ အချိန်ပြည့်သွားတာဖြစ်ဖြစ် IO ပြီးလဲ interrupt ၀င်လာတာဖြစ်ဖြစ် block ဖြစ်သွားရင် thread 2 run ပေါ့။
Concurrent နဲ. နောက်ခပ်ဆင်ဆင် တခုက paraell ဆိုတာ။ သူကျတော့ exactly တကြိမ်တည်းမှာ အပြိုင်လုပ်နေတာ။ အဲ့လိုလုပ်နိုင်ဖို. SIngle CPU နဲ.မဖြစ်နိုင်တော့ဘူး။ Single CPU ဆိုရင်တောင် Multiple Core ဖြစ်ရမယ် ဘာလို.လဲဆိုတော့ အလုပ်တွေကို parallel လုပ်ချင်ရင် parallel လုပ်နိုင်တဲ့ CPU တွေ core တွေ ရှိမှ ရမှာကိုး။
ခုနက Concurrent , Parallel နဲ. နောက်ထပ် ဆပ်နွယ်နေတာက Asynchronous , Synchronous programming ဆိုတာ။ Synchronous ဆိုတာ ရှင်းတယ် statement 1, 2, 3 run ရင် အဖြေ 1, 2,3, order အတိုင်းရမယ်။ Order အရဖြစ်လို. synchronous လို.ပြောတယ်။ Asynchronous ဆိုတာ Order တူချင်မှတူမယ်။ 1,2,3 run ပေမဲ့လိ. 2 က အရင်ပြီးသွားတာလဲဖြစ်နိုင်တယ်။ ဥပမာ Ajax call တွေလိုပေါ့။ နောက်ပိုင်း modern programming language တွေ ဥပမာ C# လိုကောင်မျိုးမှာ asynchrnous programming မျိုးရတယ်။ နောက် JS မှာလဲ async/wait ဆိုတာတွေ ပေးလာတယ်။
Asynchronous မှာ Order သည် ဘယ်ကောင်အရင်ပြီးမယ် မှန်းမသိနိုင်ဘူး ဥပမာ Ajax call 1, 2, 3 လွှတ်လိုက်ရင် ဘယ်သူအရင်ပြီးမယ်ဆိုတာ မသေချာဘူး အဲ့တော့ ၃ ခုလုံးပြီးမှ လုပ်ရမယ်ဆိုရင် သူ.အတွက် programming abstraction တွေသုံးရတယ်။ ပထမဆုံး စပေါ်တာက callback, နောက် promise, အဲ့ကနေ ခု Reactive programming ဆိုတာ ဖြစ်လာတယ်။ ဒါတွေက နောက်သက်သက်ရေးမှရမယ်။
ခုနက Thread တွေသည် code တွေကို တပြိုင်တည်းနီးပါးဖြစ်စေ လုပ်နိုင် run နိုင်တယ်။ အဲ့မှာဘာပြဿနာတက်လာလဲဆိုရင် shared လုပ်ပြီးသုံးတဲ့ variable တွေရှိတယ်ဆိုပါစို.။ ဥပမာ counter ဆိုတဲ့ variable ကို thread 1 ကလဲ write မယ် thread 2 ကလဲ write မယ်ဆိုပါစို. thread 1 က write လုပ်နေချိန်မှာ thread 2 ကမသိပဲ write လိုက်မယ်။
ဥပမာ thread 1 က counter = 10 လုပ်လိုက်တယ်။ အဲ့အချိန် thread 2 က 11 ဆိုပြီး write လိုက်တယ်။ ခုနက thread 1 က counter ကိုပြန်ဖတ်တယ်။ အဲ့တာဆို ဘာမှ ကာမထားတဲ့အတွက် data synchronization problem ဖြစ်သွားတယ်။ ဒါမျိုးကို Councurrency problem လို.ခေါ်တယ်။ အဲ့လို variable တခု တည်းကို thread တွေ အများကြီးကနေ ခွဲသုံးနိုင်တဲ့ code မျိုးကို critical section လို.ခေါ်တယ်။ အဲ့လိုမဖြစ်အောင် variable ကို thread တခုက သုံးနေရင် နောက် thread က မသုံးရအောင် ကာထားရတယ်။ အိမ်သာ တက်သလိုပေါ့။ တယောက်ယောက်က တလုံးတည်းရှိတဲ့အိမ်သာကို တက်နေရင် ဂျက်ချထားရတယ်။ ဒါမှ တခြားသူ သုံးလို.မရမှာ။ သူပြီးရင် သွား ဂျက်ဖွင့် တခြားသူသုံးလို.ရတယ်။ အဲ့တော့ ဘာဖြစ်သလဲဆိုတော့ ဂျက်ချထားရင် စောင့်နေရတယ်။ဒါမျိုးကို lock waiting လို.ခေါ်တယ်။
ခုနက Concurrency problem synchronization ကိုရှင်းဖို. language တွေက ဘာတွေပေးထားလဲဆိုတော့ Monitor တို. semaphore တို.လို. synchronization mechanism တွေ ပေးထားရတယ်။
ခုနက lock တွေ ချထားတော့ ဥပမာ process 1 က task တခုလုပ်ဖို. resources ၂ ခုလိုတယ်။ process 2 ကလဲ ခုနကလိုပဲ task တခုလုပ်ဖို. resources 2 ခုလိုတယ်စိုပါစို။ ဥပမာ process 1 က စာရေးချင်တာ။ process 2 ကျတော့ပုံဆွဲချင်တာ။ resources ၂ခုသည် စာရွက်နဲ. ခဲတံဆိုပါစို. Process 1 က စာရွက်ကို ရထားတယ် lock ချထားတယ်ပေါ့။ အဲ့တော့ Process 2 ကသုံးမရဘူး။ Process 2 ကျတော့ ခဲတံကို lock ရထားတယ်။ အလုပ်ကျလုပ်လို.မရဘူး ဘာလို.ဆိုတော့ လိုတဲ့ စာရွက်ကို process 1 က ကိုင်ထားလို. ဒါမျိုးအခြေအနေကို deadlock လို.ခေါ်တယ်။
တော်သေးဘီ။
Link2=>https://supyaem.home.blog/2023/10/21/non-blocking-io-vs-blocking-io/
SPM' Notes 