ကဲ… Part 5 ကိုတောင် ရောက်လာပါပြီဗျာ။ ဒီနေ့မှာတော့ memory mangagement အပိုင်းကို လေ့လာရအောင်။ Script Language တော်တော်များများ (PHP ကဲ့သို့ ) ဟာ memory management ပိုင်းကို အလိုအလျောက်ဆောင်ရွက်ပေးပါတယ်။ ဒါပေမယ့် Objective-C မှာကတော့ သတိထားဖို့လိုပါတယ်။ object ကို create လုပ်ပြီးရင် release လုပ်ပေးဖို့လည်းလိုပါတယ်။
Other Articles In This Series
iPhone Development လုပ်ပြီဆိုရင် memory management ပိုင်းက အရေးပါပါတယ်။ ဘာလို့လည်းဆိုတော့ iPhone က memory limit က Desktop နဲ့ ယှဉ်ရင် နည်းပါတယ်။
Two Approaches
Objective-C မှာ memory management အတွက် methods ၂ မျိုးရှိပါတယ်။ ပထမက reference counting နဲ့ ဒုတိယကတော့ garbage collection ပါ။ သင့်အနေနဲ့ စဉ်းစားလို့ရတာကတော့ manual နဲ့ automatic ပေါ့။ reference counting ဆိုတာက programmer က code ထည့်ပေးရပြီး garbage collection ကတော့ system ကို အလိုအလျောက် memory managing လုပ်ခိုင်းတာပေါ့။ Garbage collection က iPhone မှာ အလုပ်မလုပ်ဘူးဆိုတာကို သတိထားဖို့လိုပါတယ်။ အဲဒါက Mac developer တွေအတွက်သာ အသုံးဝင်ပါတယ်။
Reference Counting
ကဲ… ကျွန်တော်တို့app ကို memory manage ဘယ်လိုလုပ်မလဲ။ ပထမဆုံးအနေနဲ့ ဘယ်အချိန်မှာ code က memory ကို အသုံးပြုပါသလဲ။ ကျွန်တော်တို့တွေက class instance (object) ကို ဖန်တီးလုပ်ပြီဆိုတာနဲ့ memory က allocated လုပ်ပါတယ်။ object က သေးသေးလေးပေမယ့် app က တဖြည်းဖြည်း ကြီးလာတာနဲ့အမျှ memory ပြဿနာတွေက ဖြစ်လာနိုင်ပါတယ်။
ကဲ.. ဥပမာ တစ်ခုလောက် ကြည့်ရအောင်။ ကျွန်တော်တို့ Drawing App တစ်ခုဆွဲပါတယ်။ user ဆွဲတဲ့ shape တစ်ခုတိုင်းက separate object တွေပေါ့။ ကျွန်တော်တို့မှာ shpare 100 ဆိုရင် object 100 memory ပေါ်မှာ နေရာယူသွားပါလိမ့်မယ်။ screen ကို clear လုပ်ပြီး နောက်ထပ် shape 100 ထပ်ဆွဲမယ်။ ကျွန်တော်တို့ဟာ memory manage မလုပ်ခဲ့ရင် အသစ် shape 100 လည်းပြီးရော object 200 memory ပေါ်မှာ နေရာယူထားပြီလေ။ အဲလိုမျိုးတွေ လုပ်နေရင် ကြာလာတဲ့အခါမှာ memory တွေ အရမ်းစားပါလိမ့်မယ်။
ကဲ… ကျွန်တော်တို့ reference counting နဲ့ စဉ်းစားကြည့်ရအောင်။ create new object လုပ်လိုက်တိုင်း memory ပေါ်မှာ နေရာယူသွားတယ်။ object က count 1 ဖြစ်သွားပြီ။ နောက်ထပ် object ဆောက်ရင် retain count က 2 ဖြစ်သွားပြီ။ တကယ်လို့ release ပြန်လုပ်လိုက်ရင် retain count က decrease ဖြစ်ပြီး 1 ဖြစ်သွားပါလိမ့်မယ်။ ထပ်ပြီး decrease လုပ်လိုက်ရင် 0 ဖြစ်သွားမယ်။ zero ဆိုရင် ထိန်းမထားတော့ပဲ memory ပေါ်မှာ free ဖြစ်သွားပါပြီ။
Syntax
ကျွန်တော်တို့ ပထမဆုံး object တစ်ခုကို တည်ဆောက်ပါမယ်။ object တစ်ခုကို အောက်ကလို တည်ဆောက်ပါမယ်။
myCarClass *car = [myCarClass alloc];
ကျွန်တော်တို့ object ဆောက်ပြီးသွားရင် manual release သို့မဟုတ် autorelease ကို နောက်ပိုင်းမှာ လုပ်ပါမယ်။ သတိထားဖို့က object ကို manual release လုပ်ပြီးမှ autorelease ကို သွားခိုင်းလိုက်ရင် application က crash ဖြစ်သွားနိုင်ပါတယ်။
ကျွန်တော်တို့ oject ကို alloc နဲ့ တည်ဆောက်ပြီးပါပြီ။ အဲဒါတော့ reatin လုပ်ပါမယ်။ object က ဆောက်လိုက်တော့ object count က 1 ဖြစ်သွားပါပြီ။
[car reatin];
ထပ်ပြီး reatin လုပ်လိုက်တော့ count က 2 ဖြစ်သွားပါတယ်။ ဒါကြောင့် ကျွန်တော်တို့ ၂ ကြိမ် release လုပ်ပေးဖို့လိုပါတယ်။
Autorelease and Autorelease Pool’s
XCode မှာ create project တစ်ခုဆောက်တဲ့အခါမှာ အချို့ code တွေက autorelease အတွက် ရေးထားတာကို သတိပြုမိမှာပါ။ code က အောက်ကလို မျိုး ပုံစံလေးပေါ့
NSAutoreleasePool * pool =[[NSAutoreleasePool alloc] init];
[pool drain];
Note: documentation အဟောင်းတွေမှာတော့ နောက်ဆုံး လိုင်းက drain အစား release ဖြစ်နေမှာပါ။ တကယ်တန်းတော့ အတူတူပါပဲ။ drain ပဲ သုံးသုံး release ပဲ သုံးသုံးအဆင်ပြေပါတယ်။
အပေါ်က code က autorelease အတွက်အလုပ်လုပ်ထားတာပါ။ ကျွန်တော်တို့တွေက object ကို autorelase message ပို့ထားလိုက်ပါတယ်။ drain message ကို sent လိုက်တဲ့အခါမှာတော့ object က release လုပ်သွားပါတယ်။ autorelease က အသုံးဝင်ပါတယ်။ pool စဆောက်တဲ့အချိန်ကနေ drain မလုပ်ခင်ထိ သုံးထားတဲ့ object တွေကို drain လုပ်တဲ့အချိန်မှာ အကုန် release လုပ်လိုက်ပါတယ်။ ကျွန်တော်တို့တွေ object ကို reatin count လုပ်ပေးနေစရာမလိုတော့ပဲ relase လွယ်လွယ်ကူကူ လုပ်ပေးလိုက်လို့ရပါတယ်။
Nested Autorelease Pool’s
nested autorelease pool နဲ့ ပတ်သက်ပြီးတော့ အကြမ်းရှင်းပြပေးလို့ရပါတယ်။ အဲဒါကို ဘာကြောင့်သုံးရတာလဲ။ တစ်ခါတစ်လေ loop ပတ်နေတဲ့အချိန်မှာ tempoary object ကို ဆောက်တဲ့ အခါလေးတွေ ရှိပါတယ်။
ဥပမာ။။ loop လုပ်နေတဲ့အခါမှာ temporary object ၂ ခု ဆောက်လိုက်ပါတယ်။ မလိုချင်တဲ့အခါမှာ အဲဒါကို autorelease ပြန်လုပ်ဖို့လိုပါတယ်။ အောက်က code လေးကို လေ့လာကြည့်လိုက်ပါ။
void main()
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSArray *args = [[NSProcessInfo processInfo] arguments];
for (NSString *fileName in args) {
NSAutoreleasePool *loopPool = [[NSAutoreleasePool alloc] init];
NSError *error = nil;
NSString *fileContents = [[[NSString alloc] initWithContentsOfFile:fileName
encoding:NSUTF8StringEncoding error:&error] autorelease];
/* Process the string, creating and autoreleasing more objects. */
[loopPool drain];
}
/* Do whatever cleanup is needed. */
[pool drain];
exit (EXIT_SUCCESS);
}
အဲဒီ code လေးက တော်တော်ကောင်းပါတယ်။ အဲဒီမှာ ကျွန်တော်တို့အနေနဲ့ pool တစ်ခုကို စဆောက်လိုက်တယ်။ ပြီးတော့ loop ထဲဝင်တယ်။ Loop ထဲမှာ pool ကို ထပ်ဆောက်တယ်။ အဲဒီ အချိန်မှာပဲ object ၂ ခု ထပ်ဆောက်တယ်။ ပြီးတော့ loopPool ကို drain လုပ်လိုက်တယ်။ ဒါကြောင့် pool စဆောက်တဲ့အချိန်ကနေပြီး drain လုပ်တဲ့ကြားက object တွေကို autorelease လုပ်သွားပေးပါလိမ့်မယ်။ object တွေ create လုပ်ခဲ့တဲ့အတွက် စိုးရိမ်စရာမရှိတော့ဘူးပေါ့။ နောက်ဆုံး program ပြီးသွားတော့ drain ထပ်လုပ်လိုက်တယ်။ ရှိနေတဲ့ object တွေကို အကုန် clear လုပ်သွားပေးတယ်။
loop ထဲမှာ သုံးထားတဲ့အတွက် loop လုပ်တဲ့အချိန်မှာ object တွေများလာပြီး memory တွေစားမှာ စိုးရိမ်စရာမလိုတော့ဘူးပေါ့။ တကယ်လို့သာ release သာ ပြန်မလုပ်ပေးရင် loop တွေများလာလေလေ memory က သုံးတာ များလာလေလေ ဖြစ်မှာပေါ့။
retainCount
အပေါ်မှာတုန်းကတော့ reatin နဲ့ပတ်သက်ပြီးပြောထားပြီးပါပြီ။ reatin ဘယ်နှစ်ခုရှိလဲ သိဖို့အတွက် reatinCount ကို အသုံးပြုနိုင်ပါတယ်။
NSLog(@"retainCount for car: %d", [car retainCount]);
retainCount က integer ဖြစ်တဲ့အတွက်ကြောင့် %d ကို သုံးထားပါတယ်။
Wrapping Up
Memory management က new programmer တွေအတွက် အနည်းငယ် နားလည်ရခက်ခဲနိုင်ပါတယ်။ အထူးသဖြင့် script langauge က လာတဲ့ programmer တွေအတွက်လည်း ခေါင်းရှုပ်စေနိုင်ပါတယ်။ ဒါပေမယ့် Objective-C မှာက memory management ကို ကိုယ်ပိုင် စိတ်ကျ ဖန်တီးနိုင်တဲ့အတွက်ကြောင့် program ပေါ့ပါးမှုက programmer ရဲ့ object တည်ဆောက်မှုနဲ့ release လုပ်မှုပေါ်မှာ မူတည်နေပါတယ်။ နားမလည်တာတွေကို မေးနိုင်ပါတယ်။
Next Time
နောက်တစ်ပိုင်းမှာတော့ Objectiv-C နဲ့ ပတ်သက်ပြီး ရိုးရှင်းတဲ့ code တွေအကြောင်းရေးသားသွားပါအုံးမယ်။
reference: http://mobile.tutsplus.com/tutorials/iphone/learn-objective-c-day-5/
