လွယ်လွယ်ပြောရရင် Garbage Collection (GC) ဆိုတာ program run နေတုန်း မသုံးတော့တဲ့ memory တွေကို အလိုအလျောက် ရှာပြီး ပြန်သိမ်းပေးတဲ့ စနစ်။ Program က memory ယူသုံးပြီးရင် ကိုယ်တိုင် ပြန်အပ်စရာ မလိုဘူး — GC က “ဒါတွေ မလိုတော့ဘူး” လို့ ဆုံးဖြတ်ပြီး ရှင်းပေးတယ်။

ဥပမာ ပြောရအောင်။ စားသောက်ဆိုင်တစ်ဆိုင်မှာ စားပွဲထိုးတွေ ပန်းကန်တွေ ချနေတယ်ဆိုပါစို့။ ဧည့်သည် စားပြီးသွားတဲ့ ပန်းကန်အညစ်တွေကို ဘယ်သူမှ ပြန်မသိမ်းဘူးဆိုရင် စားပွဲတွေ ပြည့်ပြီး ဆိုင်က ရပ်သွားမယ်။ Garbage Collection ဆိုတာ ပန်းကန်အညစ်တွေ လိုက်သိမ်းပေးတဲ့ အကူဝန်ထမ်းနဲ့ တူတယ် — ဘယ်စားပွဲမှာ ဧည့်သည်မရှိတော့ဘူးလဲ ကြည့်ပြီး ပန်းကန်တွေ ပြန်သိမ်း၊ စားပွဲ ပြန်ရှင်းပေးတာ။ Programmer က “ပန်းကန်သိမ်း” ဆိုတဲ့ အလုပ်ကို လုံးဝ စိတ်ပူစရာ မလိုတော့ဘူး။

နည်းပညာအရ ပြောရရင် program တစ်ခုက variable တစ်ခု ဖန်တီးလိုက်တိုင်း RAM ထဲမှာ နေရာတစ်ခု ယူတယ်။ ဥပမာ Python မှာ —


data = [1, 2, 3, 4, 5]
data = None

ပထမစာကြောင်းက list တစ်ခုအတွက် memory ယူတယ်။ ဒုတိယစာကြောင်းမှာ data က None ဖြစ်သွားတော့ အဲဒီ list ကို ဘယ်သူကမှ ရည်ညွှန်းတော့ဘူး — “မသုံးတော့တဲ့ အမှိုက်” ဖြစ်သွားပြီ။ GC က ဒါကို တွေ့ပြီး memory ပြန်သိမ်းတယ်။ ဒီနည်းလမ်းကို reference counting လို့ခေါ်တယ် — တစ်ခုခုကို ရည်ညွှန်းနေတဲ့ variable အရေအတွက် သုညဖြစ်သွားရင် ရှင်းပစ်တာ။

ဒါပေမယ့် reference counting တစ်ခုတည်းနဲ့ မလုံလောက်တဲ့ အခြေအနေရှိတယ်။ Object နှစ်ခုက တစ်ယောက်နဲ့တစ်ယောက် ရည်ညွှန်းနေပြီး အပြင်က ဘယ်သူကမှ သူတို့ကို မသုံးတော့တဲ့ အခြေအနေ — ဒါကို circular reference လို့ခေါ်တယ်။ ဥပမာ A က B ကို ညွှန်း၊ B က A ကို ပြန်ညွှန်းနေရင် နှစ်ယောက်လုံးရဲ့ count က သုညမဖြစ်ဘူး၊ ဒါပေမယ့် တကယ်တော့ အမှိုက်ပဲ။ ဒါကြောင့် Python, Java တို့မှာ mark-and-sweep ဆိုတဲ့ ဒုတိယနည်းလမ်း ရှိတယ်။ Program ရဲ့ အမြစ်ကနေ (variable တွေ၊ stack) စပြီး “ရောက်နိုင်သေးတဲ့” object တွေကို လိုက်မှတ်တယ် (mark)၊ ပြီးရင် မမှတ်မိထားတာတွေကို ရှင်းပစ်တယ် (sweep)။ စားပွဲထိုးက ဆိုင်ထဲ ဧည့်သည်ရှိတဲ့ စားပွဲတွေကို အရင်မှတ်ပြီး ကျန်တဲ့ စားပွဲတွေ ရှင်းသလိုပဲ။

GC ရှိတဲ့ ဘာသာစကားတွေက ဘယ်ဟာတွေလဲ —

Python — reference counting + mark-and-sweep နှစ်မျိုးလုံး
Java, C# — JVM / .NET ရဲ့ GC က အရမ်းတော်တယ်
JavaScript — browser ထဲမှာ GC အလိုလို run တယ်
Go — concurrent GC, program ရပ်စရာမလိုဘဲ ရှင်းတယ်

GC မရှိတဲ့ ဘာသာစကားတွေလည်း ရှိတယ် — C, C++ တို့မှာ programmer ကိုယ်တိုင် memory ပြန်အပ်ရတယ် (free(), delete)။ မေ့သွားရင် memory leak ဖြစ်တယ် — ပန်းကန်အညစ်တွေ စုပုံပြီး ဆိုင်ပြည့်သွားသလိုမျိုး။ Program ကြာကြာဖွင့်ထားရင် RAM ကုန်ပြီး နှေးလာတာ၊ နောက်ဆုံး crash ဖြစ်တာမျိုး။

GC ရဲ့ အားနည်းချက်က တစ်ခုရှိတယ် — ရှင်းတဲ့ အချိန်ကို programmer က ထိန်းချုပ်လို့မရဘူး။ GC run တဲ့အခါ program ခေတ္တ ရပ်သွားတတ်တယ် (stop-the-world pause)။ Game လို frame တစ်စက္ကန့်ကို အကြိမ် ၆၀ ပြရတဲ့ program တွေမှာ ဒီရပ်ဆိုင်းမှုက ထင်ရှားတယ်။ ဒါကြောင့် game engine တွေ၊ operating system တွေကို C++ လို manual memory ဘာသာစကားနဲ့ ရေးကြတာ။

စိတ်ဝင်စားစရာကောင်းတာက Rust ဆိုတဲ့ ဘာသာစကားသစ်။ သူက GC လည်း မသုံးဘူး၊ manual လည်း မဟုတ်ဘူး — ownership ဆိုတဲ့ စည်းမျဉ်းနဲ့ compiler က compile လုပ်တဲ့ အချိန်မှာတင် ဘယ် memory ဘယ်တော့ ရှင်းရမလဲ ဆုံးဖြတ်ပေးတယ်။ အမှိုက်သိမ်းဝန်ထမ်း မလိုဘဲ ဆိုင်ဒီဇိုင်းကိုက ပန်းကန်အညစ် အလိုလို ကျသွားအောင် လုပ်ထားသလိုမျိုး။

ကျွန်တော် Python စသင်တုန်းက memory အကြောင်း လုံးဝ မစဉ်းစားခဲ့ရဘူး — variable ဖန်တီးလိုက်၊ သုံးလိုက်၊ ပြီးရင် မေ့လိုက်နဲ့။ နောက်မှ C သင်တော့ malloc ပြီးတိုင်း free လုပ်ရမှန်းသိပြီး GC ရဲ့ ကျေးဇူးကို နားလည်သွားတယ်။ အလိုလို ရှင်းပေးတဲ့စနစ်ဆိုတာ သာမန်လို့ ထင်ရပေမယ့် နောက်ကွယ်မှာ တော်တော် ဉာဏ်ကောင်းတဲ့ အင်ဂျင်နီယာပညာ ရှိတယ်။

===