Objective����������� ������������������ -����������� ������������������ C����������� ������������������ Memory����������� ������������������ Management
Cha,����������� ������������������ Yong-Bin
http://blog.daum.net/teddyp418
MEMORY…⋯…⋯…⋯…⋯
-����������� ������������������ 참고문서����������� ������������������ -
iOS와����������� ������������������ 맥OSX����������� ������������������ 개발을����������� ������������������ 위한����������� ������������������ Objective����������� ������������������ -����������� ������������������ C����������� ������������������ 2판����������� ������������������ Programming����������� ������������������ in����������� ������������������ Objective-C����������� ������������������ 2.0����������� ������������������ 4/E����������� ������������������ 사전처럼����������� ������������������ 바로����������� ������������������ 찾아����������� ������������������ 바로쓰는����������� ������������������ 오브젝티브-C����������� ������������������ 핸드북����������� ������������������ http://goo.gl/OPMp77
C의����������� ������������������ 메모리����������� ������������������ 관리����������� ������������������ 규칙
Objective-C는����������� ������������������ C의����������� ������������������ 상위집합으로����������� ������������������ 기본적으로는����������� ������������������ C의����������� ������������������ 메모리����������� ������������������ 관리����������� ������������������ 규칙을����������� ������������������ 따른다.
1. *alloc으로����������� ������������������ 할당한����������� ������������������ 메모리는����������� ������������������ 반드시����������� ������������������ free����������� ������������������ 해야����������� ������������������ 한다.����������� ������������������ 코드����������� ������������������ 전체에����������� ������������������ 대해����������� ������������������ alloc����������� ������������������ 과����������� ������������������ free의����������� ������������������ 짝이����������� ������������������ 맞아야����������� ������������������ 한다.����������� ������������������
2. alloc을����������� ������������������ 수행한����������� ������������������ 함수가����������� ������������������ free의����������� ������������������ 책임을����������� ������������������ 져야����������� ������������������ 한다.����������� ������������������ 3. 2가����������� ������������������ 어려운����������� ������������������ 경우에는����������� ������������������ (새로����������� ������������������ 할당한����������� ������������������ 메모리의����������� ������������������ 주소를����������� ������������������ 리턴하는����������� ������������������ 함수����������� ������������������
등)����������� ������������������ 이를����������� ������������������ 호출하는����������� ������������������ 쪽에서����������� ������������������ free의����������� ������������������ 책임을����������� ������������������ 져야����������� ������������������ 한다.
출처����������� ������������������ :����������� ������������������ http://soooprmx.com/wp/archives/4174
Objective-C의����������� ������������������ 메모리����������� ������������������ 관리����������� ������������������ 규칙
1. new,����������� ������������������ alloc,����������� ������������������ copy로����������� ������������������ 객체를����������� ������������������ 생성하는����������� ������������������ 경우����������� ������������������ 이����������� ������������������ 객체는����������� ������������������ 해당����������� ������������������ 시점
에����������� ������������������ 1의����������� ������������������ 참조횟수(retain����������� ������������������ count)를����������� ������������������ 가지게����������� ������������������ 된다.����������� ������������������
2. 객체를����������� ������������������ 쓰고����������� ������������������ 더����������� ������������������ 이상����������� ������������������ 필요����������� ������������������ 없는����������� ������������������ 시점이라면����������� ������������������ release����������� ������������������ 메시지를����������� ������������������ 보낸
다.����������� ������������������ 이는����������� ������������������ 객체의����������� ������������������ 참조횟수를����������� ������������������ 1만큼����������� ������������������ 감소����������� ������������������ 시킨다.����������� ������������������ 따라서����������� ������������������ 어떤����������� ������������������ 함수����������� ������������������
내에서����������� ������������������ alloc����������� ������������������ 으로����������� ������������������ 생성한����������� ������������������ 객체에����������� ������������������ release메시지를����������� ������������������ 보내면����������� ������������������ 해당����������� ������������������
객체의����������� ������������������ 참조횟수는����������� ������������������ 0이되고,����������� ������������������ 런타임은����������� ������������������ 해당����������� ������������������ 객체를����������� ������������������ 파괴한다.
출처����������� ������������������ :����������� ������������������ http://soooprmx.com/wp/archives/4174
Objective-C의����������� ������������������ 메모리����������� ������������������ 관리����������� ������������������ 규칙
출처����������� ������������������ :����������� ������������������ http://soooprmx.com/wp/archives/4174
3. 함수����������� ������������������ 내에서����������� ������������������ 객체를����������� ������������������ 생성해서����������� ������������������ 반환해야����������� ������������������ 하는����������� ������������������ 경우에는,����������� ������������������ 리턴하기����������� ������������������
전에����������� ������������������ 생성한����������� ������������������ 객체에����������� ������������������ autorelease����������� ������������������ 메시지를����������� ������������������ 보내어,����������� ������������������ 오토릴리즈����������� ������������������ 풀
이����������� ������������������ 해제될����������� ������������������ 때����������� ������������������ 객체가����������� ������������������ release����������� ������������������ 될����������� ������������������ 수����������� ������������������ 있도록����������� ������������������ 한다.����������� ������������������
4. 만약����������� ������������������ 1에서����������� ������������������ 언급한����������� ������������������ 방식이����������� ������������������ 아닌����������� ������������������ 다른����������� ������������������ 방식으로����������� ������������������ 획득한����������� ������������������ 객체가����������� ������������������ 있다
면����������� ������������������ (다른����������� ������������������ 함수의����������� ������������������ 결과로����������� ������������������ 리턴된����������� ������������������ 객체����������� ������������������ 포인터)����������� ������������������ 객체를����������� ������������������ 획득하는����������� ������������������ 시
점에서의����������� ������������������ 참조횟수는����������� ������������������ 1로����������� ������������������ 보고,����������� ������������������ 이����������� ������������������ 객체는����������� ������������������ autorelease된다고����������� ������������������ 보면����������� ������������������
된다.
…⋯…⋯…⋯…⋯…⋯…⋯
객체의����������� ������������������ 일생
객체는����������� ������������������ alloc����������� ������������������ 또는����������� ������������������ new로����������� ������������������ 태어난다.����������� ������������������ ����������� ������������������
객체의����������� ������������������ 일생이����������� ������������������ 끝나면����������� ������������������ 그����������� ������������������ 객체가����������� ������������������ 사용하던����������� ������������������ 메모리는����������� ������������������ ����������� ������������������
다음에����������� ������������������ 태어날����������� ������������������ 객체를����������� ������������������ 위하여����������� ������������������ 정리가����������� ������������������ 되어야한다.
alloc����������� ������������������ /����������� ������������������ new����������� ������������������ /����������� ������������������ copy����������� ������������������ 객체의����������� ������������������ 참조횟수는����������� ������������������ 1
retain����������� ������������������
release
참조횟수����������� ������������������ 증가����������� ������������������ ����������� ������������������
참조횟수����������� ������������������ 감소
참조횟수가����������� ������������������ 0일때����������� ������������������ ����������� ������������������
자동으로����������� ������������������ 메시지����������� ������������������ 전달
dealloc����������� ������������������ 객체����������� ������������������ 소멸����������� ������������������ /����������� ������������������ 오버라이드����������� ������������������ 가능
alloc����������� ������������������ /����������� ������������������ new����������� ������������������ /����������� ������������������ copy����������� ������������������ 객체의����������� ������������������ 참조횟수는����������� ������������������ 1
retain����������� ������������������
release
참조횟수����������� ������������������ 증가����������� ������������������ ����������� ������������������
참조횟수����������� ������������������ 감소
참조횟수가����������� ������������������ 0일때����������� ������������������ ����������� ������������������
자동으로����������� ������������������ 메시지����������� ������������������ 전달
dealloc����������� ������������������ 객체����������� ������������������ 소멸����������� ������������������ /����������� ������������������ 오버라이드����������� ������������������ 가능
alloc����������� ������������������ /����������� ������������������ new����������� ������������������ /����������� ������������������ copy����������� ������������������ 객체의����������� ������������������ 참조횟수는����������� ������������������ 1
retain����������� ������������������
release
참조횟수����������� ������������������ 증가����������� ������������������ ����������� ������������������
참조횟수����������� ������������������ 감소
참조횟수가����������� ������������������ 0일때����������� ������������������ ����������� ������������������
자동으로����������� ������������������ 메시지����������� ������������������ 전달
dealloc����������� ������������������ 객체����������� ������������������ 소멸����������� ������������������ /����������� ������������������ 오버라이드����������� ������������������ 가능
<관련 API> - (id) retain; - (void) release; - (unsigned) retainCount;
@implementation����������� ������������������ RetainTracker����������� ������������������
-����������� ������������������ (id)init����������� ������������������ {����������� ������������������ ����������� ������������������ if(self����������� ������������������ =����������� ������������������ [super����������� ������������������ init])����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"init:����������� ������������������ Retain����������� ������������������ count����������� ������������������ of����������� ������������������ %lu.",����������� ������������������ [self����������� ������������������ retainCount]);����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ (self);����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������ //����������� ������������������ snit����������� ������������������
-����������� ������������������ (void)����������� ������������������ dealloc����������� ������������������ {����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"dealloc����������� ������������������ called.����������� ������������������ Bye����������� ������������������ Bye.");����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [super����������� ������������������ dealloc];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������ //����������� ������������������ dealloc����������� ������������������
@end����������� ������������������ //����������� ������������������ RetainTracker
init 메소드는 코코아에서 객체 초기화를 하는 표준 메소드 -> 10장에서…
객체의 참조횟수가 0이 되면 dealloc 메시지가 자동으로 보내진다. 그 결과 dealloc 메소드가 호출된다.
int����������� ������������������ main(int����������� ������������������ argc,����������� ������������������ const����������� ������������������ char����������� ������������������ *����������� ������������������ argv[])����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ RetainTracker����������� ������������������ *tracker����������� ������������������ =����������� ������������������ [RetainTracker����������� ������������������ new];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ retain];����������� ������������������ //����������� ������������������ count:����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"%lu",����������� ������������������ [tracker����������� ������������������ retainCount]);����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ retain];����������� ������������������ //����������� ������������������ count:����������� ������������������ 3����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"%lu",����������� ������������������ [tracker����������� ������������������ retainCount]);����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ release];����������� ������������������ //����������� ������������������ count:����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"%lu",����������� ������������������ [tracker����������� ������������������ retainCount]);����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ release];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"%lu",����������� ������������������ [tracker����������� ������������������ retainCount]);����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ retain];����������� ������������������ //����������� ������������������ count����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"%lu",����������� ������������������ [tracker����������� ������������������ retainCount]);����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ release];����������� ������������������ //����������� ������������������ count����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"%lu",����������� ������������������ [tracker����������� ������������������ retainCount]);����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ release];����������� ������������������ //����������� ������������������ count:����������� ������������������ 0,����������� ������������������ dealloc����������� ������������������ it����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ (0);����������� ������������������ }
init: Retain count of 1. 2 3 2 1 2 1 dealloc called. Bye Bye.
오토릴리즈
함수����������� ������������������ 내에서����������� ������������������ 새로운����������� ������������������ 객체를����������� ������������������ 메모리를����������� ������������������ 할당해����������� ������������������ 생성하고����������� ������������������ ����������� ������������������
이를����������� ������������������ 리턴하는����������� ������������������ 경우가����������� ������������������ 많다…⋯
Foudation에서는����������� ������������������ 오토릴리즈����������� ������������������ 풀이라는����������� ������������������ 기능을����������� ������������������ 사용하여����������� ������������������ 함수����������� ������������������ 내에서����������� ������������������ 생성한����������� ������������������
객체들을����������� ������������������ 적절한����������� ������������������ 시점에����������� ������������������ 한����������� ������������������ 번에����������� ������������������ 해제할����������� ������������������ 수����������� ������������������ 있도록����������� ������������������ 해주는����������� ������������������ 방법을����������� ������������������ 제공
오토릴리즈����������� ������������������ 풀
NSObject에서����������� ������������������ autorelease����������� ������������������ 메소드����������� ������������������ 제공
어떤����������� ������������������ 객체에����������� ������������������ autorelease를����������� ������������������ 보내면����������� ������������������ 그����������� ������������������ 객체가����������� ������������������ NSAutoreleasePool에����������� ������������������ 추가����������� ������������������
풀이����������� ������������������ 사라질����������� ������������������ 때,����������� ������������������ 풀에����������� ������������������ 있던����������� ������������������ 모든����������� ������������������ 객체에����������� ������������������ 릴리즈����������� ������������������ 메시지����������� ������������������ 전달
-����������� ������������������ (Id)����������� ������������������ autorelease
-����������� ������������������ (NSString����������� ������������������ *)����������� ������������������ description����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSString����������� ������������������ *description;����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ description����������� ������������������ =����������� ������������������ [[NSString����������� ������������������ alloc]����������� ������������������ initWithFormat:@"Hello"];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ (description);����������� ������������������ }
alloc을����������� ������������������ 사용해서����������� ������������������ 객체를����������� ������������������ 만들었지만...����������� ������������������ 릴리즈를����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있는����������� ������������������ 방법이����������� ������������������ 없다.
-����������� ������������������ (NSString����������� ������������������ *)����������� ������������������ description����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSString����������� ������������������ *description;����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ description����������� ������������������ =����������� ������������������ [[NSString����������� ������������������ alloc]����������� ������������������ initWithFormat:@"Hello"];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ ([description����������� ������������������ autorelease]);����������� ������������������ }
<오토릴리즈>
오토릴리즈����������� ������������������ 풀����������� ������������������ 생성법
@autoreleasepool����������� ������������������ 키워드를����������� ������������������ 사용한다.����������� ������������������
NSAutoreleasePool����������� ������������������ 객체를����������� ������������������ 사용한다.
@autoreleasepool{}����������� ������������������ 를����������� ������������������ 이용하는데,����������� ������������������ 중괄호����������� ������������������ 안에����������� ������������������ 있는����������� ������������������ 모든����������� ������������������ 코드는����������� ������������������ 새로운����������� ������������������
풀����������� ������������������ 안에����������� ������������������ 들어가게����������� ������������������ 된다.����������� ������������������
중첩해서����������� ������������������ 사용이����������� ������������������ 가능하고,����������� ������������������ 중괄호����������� ������������������ 안에서만����������� ������������������ 적용된다.
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSAutoreleasePool����������� ������������������ *pool;����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ pool����������� ������������������ =����������� ������������������ [NSAutoreleasePool����������� ������������������ new];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ …⋯����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [pool����������� ������������������ release];
#import����������� ������������������ <Foundation/Foundation.h>����������� ������������������
@interface����������� ������������������ RetainTracker����������� ������������������ :����������� ������������������ NSObject����������� ������������������ @end����������� ������������������ //����������� ������������������ RetainTracker����������� ������������������
@implementation����������� ������������������ RetainTracker����������� ������������������
-����������� ������������������ (id)����������� ������������������ init����������� ������������������ {����������� ������������������ ����������� ������������������ if����������� ������������������ (self����������� ������������������ =����������� ������������������ [super����������� ������������������ init])����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"init:����������� ������������������ Retain����������� ������������������ count����������� ������������������ of����������� ������������������ %lu.",����������� ������������������ [self����������� ������������������ retainCount]);����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ (self);����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������ //����������� ������������������ init����������� ������������������
-����������� ������������������ (void)����������� ������������������ dealloc����������� ������������������ {����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"dealloc����������� ������������������ called.����������� ������������������ Bye����������� ������������������ Bye.");����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [super����������� ������������������ dealloc];����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������ //����������� ������������������ dealloc����������� ������������������
@end����������� ������������������ //����������� ������������������ RetainTracker
int����������� ������������������ main(int����������� ������������������ argc,����������� ������������������ const����������� ������������������ char����������� ������������������ *����������� ������������������ argv[])����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSAutoreleasePool����������� ������������������ *pool����������� ������������������ =����������� ������������������ [[NSAutoreleasePool����������� ������������������ alloc]����������� ������������������ init];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ RetainTracker����������� ������������������ *tracker����������� ������������������ =����������� ������������������ [RetainTracker����������� ������������������ new];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ retain];����������� ������������������ //����������� ������������������ count:����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ autorelease];����������� ������������������ //����������� ������������������ count:����������� ������������������ still����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ release];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"releasing����������� ������������������ pool");����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [pool����������� ������������������ release];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ //����������� ������������������ gets����������� ������������������ nuked,����������� ������������������ sends����������� ������������������ release����������� ������������������ to����������� ������������������ tracker����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ @autoreleasepool����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ RetainTracker����������� ������������������ *tracker2����������� ������������������ =����������� ������������������ [RetainTracker����������� ������������������ new];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker2����������� ������������������ retain];����������� ������������������ //����������� ������������������ count:����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker2����������� ������������������ autorelease];����������� ������������������ //����������� ������������������ count:����������� ������������������ still����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker2����������� ������������������ release];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"auto����������� ������������������ releasing����������� ������������������ pool");����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ (0);����������� ������������������ }
init: Retain count of 1. releasing pool dealloc called. Bye Bye. init: Retain count of 1. auto releasing pool dealloc called. Bye Bye.
int����������� ������������������ main(int����������� ������������������ argc,����������� ������������������ const����������� ������������������ char����������� ������������������ *����������� ������������������ argv[])����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSAutoreleasePool����������� ������������������ *pool����������� ������������������ =����������� ������������������ [[NSAutoreleasePool����������� ������������������ alloc]����������� ������������������ init];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ RetainTracker����������� ������������������ *tracker����������� ������������������ =����������� ������������������ [RetainTracker����������� ������������������ new];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ retain];����������� ������������������ //����������� ������������������ count:����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ autorelease];����������� ������������������ //����������� ������������������ count:����������� ������������������ still����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ release];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"releasing����������� ������������������ pool");����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [pool����������� ������������������ release];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ //����������� ������������������ gets����������� ������������������ nuked,����������� ������������������ sends����������� ������������������ release����������� ������������������ to����������� ������������������ tracker����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ @autoreleasepool����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ RetainTracker����������� ������������������ *tracker2����������� ������������������ =����������� ������������������ [RetainTracker����������� ������������������ new];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker2����������� ������������������ retain];����������� ������������������ //����������� ������������������ count:����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker2����������� ������������������ autorelease];����������� ������������������ //����������� ������������������ count:����������� ������������������ still����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker2����������� ������������������ release];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"auto����������� ������������������ releasing����������� ������������������ pool");����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ (0);����������� ������������������ }
참조횟수는����������� ������������������ 바뀌지����������� ������������������ 않는다.����������� ������������������ ����������� ������������������
앞서����������� ������������������ 만들어진����������� ������������������ 풀이����������� ������������������ 이����������� ������������������ 객체에����������� ������������������ 대한����������� ������������������
참조를����������� ������������������ 갖는다.
init: Retain count of 1. releasing pool dealloc called. Bye Bye. init: Retain count of 1. auto releasing pool dealloc called. Bye Bye.
객체를����������� ������������������ 각각����������� ������������������ 풀에����������� ������������������ 할당을����������� ������������������ 하고����������� ������������������ 해제를����������� ������������������ 하는����������� ������������������ 과정을����������� ������������������ 거친다.����������� ������������������
새로운����������� ������������������ 풀을����������� ������������������ 만들었다.
풀을����������� ������������������ 릴리지한다.
int����������� ������������������ main(int����������� ������������������ argc,����������� ������������������ const����������� ������������������ char����������� ������������������ *����������� ������������������ argv[])����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSAutoreleasePool����������� ������������������ *pool����������� ������������������ =����������� ������������������ [[NSAutoreleasePool����������� ������������������ alloc]����������� ������������������ init];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ RetainTracker����������� ������������������ *tracker����������� ������������������ =����������� ������������������ [RetainTracker����������� ������������������ new];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ retain];����������� ������������������ //����������� ������������������ count:����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ autorelease];����������� ������������������ //����������� ������������������ count:����������� ������������������ still����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker����������� ������������������ release];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"releasing����������� ������������������ pool");����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [pool����������� ������������������ release];����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ //����������� ������������������ gets����������� ������������������ nuked,����������� ������������������ sends����������� ������������������ release����������� ������������������ to����������� ������������������ tracker����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ @autoreleasepool����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ RetainTracker����������� ������������������ *tracker2����������� ������������������ =����������� ������������������ [RetainTracker����������� ������������������ new];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker2����������� ������������������ retain];����������� ������������������ //����������� ������������������ count:����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker2����������� ������������������ autorelease];����������� ������������������ //����������� ������������������ count:����������� ������������������ still����������� ������������������ 2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [tracker2����������� ������������������ release];����������� ������������������ //����������� ������������������ count:����������� ������������������ 1����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NSLog����������� ������������������ (@"auto����������� ������������������ releasing����������� ������������������ pool");����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ (0);����������� ������������������ }
init: Retain count of 1. releasing pool dealloc called. Bye Bye. init: Retain count of 1. auto releasing pool dealloc called. Bye Bye.
중괄호가����������� ������������������ 끝나는����������� ������������������ 시점에����������� ������������������ 풀����������� ������������������ 릴리즈
@autoreleasepool����������� ������������������ 메소드는����������� ������������������ 동일하지만����������� ������������������ 번거롭게����������� ������������������ 객체를����������� ������������������
할당하고����������� ������������������ 해제하지����������� ������������������ 않는다.
Objective-C의����������� ������������������ 메모리����������� ������������������ 관리����������� ������������������ 규칙
1. new,����������� ������������������ alloc,����������� ������������������ copy로����������� ������������������ 객체를����������� ������������������ 생성하는����������� ������������������ 경우����������� ������������������ 이����������� ������������������ 객체는����������� ������������������ 해당����������� ������������������ 시점
에����������� ������������������ 1의����������� ������������������ 참조횟수(retain����������� ������������������ count)를����������� ������������������ 가지게����������� ������������������ 된다.����������� ������������������
2. 객체를����������� ������������������ 쓰고����������� ������������������ 더����������� ������������������ 이상����������� ������������������ 필요����������� ������������������ 없는����������� ������������������ 시점이라면����������� ������������������ release����������� ������������������ 메시지를����������� ������������������ 보낸
다.����������� ������������������ 이는����������� ������������������ 객체의����������� ������������������ 참조횟수를����������� ������������������ 1만큼����������� ������������������ 감소����������� ������������������ 시킨다.����������� ������������������ 따라서����������� ������������������ 어떤����������� ������������������ 함수����������� ������������������
내에서����������� ������������������ alloc����������� ������������������ 으로����������� ������������������ 생성한����������� ������������������ 객체에����������� ������������������ release메시지를����������� ������������������ 보내면����������� ������������������ 해당����������� ������������������
객체의����������� ������������������ 참조횟수는����������� ������������������ 0이되고,����������� ������������������ 런타임은����������� ������������������ 해당����������� ������������������ 객체를����������� ������������������ 파괴한다.
출처����������� ������������������ :����������� ������������������ http://soooprmx.com/wp/archives/4174
다시보는
Objective-C의����������� ������������������ 메모리����������� ������������������ 관리����������� ������������������ 규칙
출처����������� ������������������ :����������� ������������������ http://soooprmx.com/wp/archives/4174
3. 함수����������� ������������������ 내에서����������� ������������������ 객체를����������� ������������������ 생성해서����������� ������������������ 반환해야����������� ������������������ 하는����������� ������������������ 경우에는,����������� ������������������ 리턴하기����������� ������������������
전에����������� ������������������ 생성한����������� ������������������ 객체에����������� ������������������ autorelease����������� ������������������ 메시지를����������� ������������������ 보내어,����������� ������������������ 오토릴리즈����������� ������������������ 풀
이����������� ������������������ 해제될����������� ������������������ 때����������� ������������������ 객체가����������� ������������������ release����������� ������������������ 될����������� ������������������ 수����������� ������������������ 있도록����������� ������������������ 한다.����������� ������������������
4. 만약����������� ������������������ 1에서����������� ������������������ 언급한����������� ������������������ 방식이����������� ������������������ 아닌����������� ������������������ 다른����������� ������������������ 방식으로����������� ������������������ 획득한����������� ������������������ 객체가����������� ������������������ 있다
면����������� ������������������ (다른����������� ������������������ 함수의����������� ������������������ 결과로����������� ������������������ 리턴된����������� ������������������ 객체����������� ������������������ 포인터)����������� ������������������ 객체를����������� ������������������ 획득하는����������� ������������������ 시
점에서의����������� ������������������ 참조횟수는����������� ������������������ 1로����������� ������������������ 보고,����������� ������������������ 이����������� ������������������ 객체는����������� ������������������ autorelease된다고����������� ������������������ 보면����������� ������������������
된다.
다시보는
쉬운����������� ������������������ 방법은����������� ������������������ 없나..����������� ������������������ 에효
가비지����������� ������������������ 컬렉션����������� ������������������ (garbage����������� ������������������ collection)
실행����������� ������������������ 중����������� ������������������ 적절한����������� ������������������ 시점에����������� ������������������ 프로그램����������� ������������������ 내의����������� ������������������ 객체들을����������� ������������������ 검사하여����������� ������������������ 외부에서����������� ������������������ 이����������� ������������������
객체에����������� ������������������ 대한����������� ������������������ 참조가����������� ������������������ 없는����������� ������������������ 경우����������� ������������������ 이를����������� ������������������ 쓰레기로����������� ������������������ 판단,����������� ������������������ 자동으로����������� ������������������ 파괴해����������� ������������������ 버
린다.����������� ������������������ 따라서����������� ������������������ 프로그래머는����������� ������������������ 객체가����������� ������������������ 더이상����������� ������������������ 필요없는����������� ������������������ 시점이����������� ������������������ 되면����������� ������������������ 해당����������� ������������������
객체의����������� ������������������ 포인터에����������� ������������������ nil을����������� ������������������ 대입해주기만����������� ������������������ 하면����������� ������������������ 된다.����������� ������������������
=>����������� ������������������ GC는����������� ������������������ 상당히����������� ������������������ 비용이����������� ������������������ 많이����������� ������������������ 드는����������� ������������������ 작업.����������� ������������������ 모든����������� ������������������ 객체를����������� ������������������ 검사하기에는����������� ������������������ 앱����������� ������������������
사용중����������� ������������������ 메모리가����������� ������������������ 부족할����������� ������������������ 수����������� ������������������ 있고,����������� ������������������ 잠깐의����������� ������������������ 멈추는����������� ������������������ 상황이����������� ������������������ 올����������� ������������������ 수����������� ������������������ 있음����������� ������������������
iOS에선����������� ������������������ GC는����������� ������������������ 사용할����������� ������������������ 수����������� ������������������ 없고����������� ������������������ MAC����������� ������������������ OS에서����������� ������������������ 사용가능����������� ������������������
헐…⋯…⋯…⋯
ARC����������� ������������������ (Automatic����������� ������������������ Reference����������� ������������������ Counting)
iOS에서����������� ������������������ 가비지����������� ������������������ 컬렉션을����������� ������������������ 대신할����������� ������������������ 수����������� ������������������ 있는����������� ������������������ 것이����������� ������������������ ARC이다.����������� ������������������
ARC는����������� ������������������ 객체를����������� ������������������ 추적하여����������� ������������������ 유지하려는����������� ������������������ 객체와����������� ������������������ 그렇지����������� ������������������ 않은����������� ������������������ 객체를����������� ������������������ 결정.����������� ������������������
retain과����������� ������������������ release하는����������� ������������������ 코드를����������� ������������������ 컴파일러가����������� ������������������ 컴파일����������� ������������������ 시점에����������� ������������������ 소스����������� ������������������ 곳곳에����������� ������������������
적절하게����������� ������������������ 추가해준다.����������� ������������������ 개발자는����������� ������������������ 강한����������� ������������������ 참조든����������� ������������������ 약한����������� ������������������ 참조든����������� ������������������ 신경쓰지����������� ������������������ 않
고����������� ������������������ 그냥����������� ������������������ ‘참조’만����������� ������������������ 하면����������� ������������������ 된다.
ARC����������� ������������������ 사용����������� ������������������ 규칙
1. 명시적으로����������� ������������������ dealloc을����������� ������������������ 호출해서는����������� ������������������ 안된다.����������� ������������������
2. retain,����������� ������������������ release,����������� ������������������ retainCount,����������� ������������������ autorelease를����������� ������������������ 명시적으로����������� ������������������ 호
출하거나����������� ������������������ 오버라이드����������� ������������������ 할����������� ������������������ 수����������� ������������������ 없다.����������� ������������������
3. C구조체����������� ������������������ 내에����������� ������������������ Objective-C����������� ������������������ 객체����������� ������������������ 포인터를����������� ������������������ 저장할����������� ������������������ 수����������� ������������������ 없다.����������� ������������������ 구조
체보다는����������� ������������������ Objective-C����������� ������������������ 객체를����������� ������������������ 쓸����������� ������������������ 것을����������� ������������������ 추천한다.����������� ������������������
4. id����������� ������������������ 와����������� ������������������ void����������� ������������������ *간의����������� ������������������ 캐주얼����������� ������������������ 캐스팅을����������� ������������������ 쓸����������� ������������������ 수����������� ������������������ 없다.����������� ������������������ 이들����������� ������������������ 간의����������� ������������������ 캐스팅
에서는����������� ������������������ 컴파일러가����������� ������������������ 객체의����������� ������������������ 라이프사이클을����������� ������������������ 파악할����������� ������������������ 수����������� ������������������ 있도록����������� ������������������ 추가적
인����������� ������������������ 지시어����������� ������������������ (__reatin����������� ������������������ 등)를����������� ������������������ 써서����������� ������������������ 관계를����������� ������������������ 명시해야����������� ������������������ 한다.
ARC����������� ������������������ 사용����������� ������������������ 규칙
5. NSAutoreleasePool����������� ������������������ 객체는����������� ������������������ 더����������� ������������������ 이상����������� ������������������ 쓸����������� ������������������ 수����������� ������������������ 없다.����������� ������������������
@autoreleasepool{����������� ������������������ }����������� ������������������ 블럭을����������� ������������������ 사용한다.����������� ������������������
6. 접근자명에����������� ������������������ new를����������� ������������������ 붙일����������� ������������������ 수����������� ������������������ 없다.����������� ������������������ @property����������� ������������������ NSString����������� ������������������
*newTitle;은����������� ������������������ 컴파일����������� ������������������ 오류를����������� ������������������ 일으킨다.����������� ������������������
7. 단,����������� ������������������ getter����������� ������������������ 명을����������� ������������������ 바꾸면����������� ������������������ 쓸����������� ������������������ 수는����������� ������������������ 있다.����������� ������������������ @property����������� ������������������
(getter=theNewTitle)����������� ������������������ NSString����������� ������������������ *newTitle;은����������� ������������������ 동작한다.
ARC����������� ������������������ <새로운����������� ������������������ 프로퍼티����������� ������������������ 지정자>
ARC����������� ������������������ 이전의����������� ������������������ 프로퍼티����������� ������������������ 지정자는����������� ������������������ retain,����������� ������������������ assign����������� ������������������ 같은����������� ������������������ 것들이����������� ������������������ 있었는데����������� ������������������
이들은����������� ������������������ 보다����������� ������������������ 명시적으로����������� ������������������ 참조의����������� ������������������ 종류를����������� ������������������ 가리키도록����������� ������������������ strong,����������� ������������������ weak로����������� ������������������ 변경
된다.����������� ������������������ strong����������� ������������������ 속성을����������� ������������������ 부여한����������� ������������������ 프로퍼티는����������� ������������������ 세팅시에����������� ������������������ 참조수를����������� ������������������ 올려����������� ������������������ 외부에서����������� ������������������
릴리즈되더라도����������� ������������������ 해당����������� ������������������ 객체가����������� ������������������ 소멸될����������� ������������������ 때까지����������� ������������������ 참조를����������� ������������������ 유지한다.����������� ������������������ weak����������� ������������������
속성으로����������� ������������������ 선언된����������� ������������������ 프로퍼티는����������� ������������������ 참조수를����������� ������������������ 올려����������� ������������������ 유지하지����������� ������������������ 않는대신,����������� ������������������ 외부에서����������� ������������������ 가
리키고����������� ������������������ 있던����������� ������������������ 객체가����������� ������������������ 해제된����������� ������������������ 경우����������� ������������������ 자동으로����������� ������������������ nil을����������� ������������������ 가리키도록����������� ������������������ 변경된다.����������� ������������������
ARC의����������� ������������������ 디폴트����������� ������������������ 지정자는����������� ������������������ strong����������� ������������������ 이다.
ARC����������� ������������������ <새로운����������� ������������������ 프로퍼티����������� ������������������ 지정자>
ARC����������� ������������������ 이전의����������� ������������������ 프로퍼티����������� ������������������ 지정자는����������� ������������������ retain,����������� ������������������ assign����������� ������������������ 같은����������� ������������������ 것들이����������� ������������������ 있었는데����������� ������������������
이들은����������� ������������������ 보다����������� ������������������ 명시적으로����������� ������������������ 참조의����������� ������������������ 종류를����������� ������������������ 가리키도록����������� ������������������ strong,����������� ������������������ weak로����������� ������������������ 변경
된다.����������� ������������������ strong����������� ������������������ 속성을����������� ������������������ 부여한����������� ������������������ 프로퍼티는����������� ������������������ 세팅시에����������� ������������������ 참조수를����������� ������������������ 올려����������� ������������������ 외부에서����������� ������������������
릴리즈되더라도����������� ������������������ 해당����������� ������������������ 객체가����������� ������������������ 소멸될����������� ������������������ 때까지����������� ������������������ 참조를����������� ������������������ 유지한다.����������� ������������������ weak����������� ������������������
속성으로����������� ������������������ 선언된����������� ������������������ 프로퍼티는����������� ������������������ 참조수를����������� ������������������ 올려����������� ������������������ 유지하지����������� ������������������ 않는대신,����������� ������������������ 외부에서����������� ������������������ 가
리키고����������� ������������������ 있던����������� ������������������ 객체가����������� ������������������ 해제된����������� ������������������ 경우����������� ������������������ 자동으로����������� ������������������ nil을����������� ������������������ 가리키도록����������� ������������������ 변경된다.����������� ������������������
ARC의����������� ������������������ 디폴트����������� ������������������ 지정자는����������� ������������������ strong����������� ������������������ 이다.
ARC����������� ������������������ 기능����������� ������������������ -����������� ������������������ 객체간의����������� ������������������ 참조����������� ������������������ 카운터를����������� ������������������ 자동으로����������� ������������������ 관리
Strong����������� ������������������ 참조����������� ������������������ 한객체가����������� ������������������ 다른����������� ������������������ 객체를����������� ������������������ Strong����������� ������������������ 참조하고����������� ������������������ 있는����������� ������������������ 경우,����������� ������������������ ����������� ������������������
참조되고����������� ������������������ 있는����������� ������������������ 객체가����������� ������������������ 소멸되지����������� ������������������ 않는다.����������� ������������������ ����������� ������������������
weak����������� ������������������ 참조����������� ������������������ 한객체가����������� ������������������ 다른����������� ������������������ 객체를����������� ������������������ weak����������� ������������������ 참조하고����������� ������������������ 있는����������� ������������������ 경우,����������� ������������������ ����������� ������������������ 참조하고����������� ������������������ 있는����������� ������������������ 객체가����������� ������������������ 소멸되면����������� ������������������ nil을����������� ������������������ 가르킨다.����������� ������������������
A
B
C
D
E
A가����������� ������������������ B를����������� ������������������ 참조하지����������� ������������������ 않게����������� ������������������ 되면?
A
B
C
D
E
B가����������� ������������������ 소멸되지����������� ������������������ 않고����������� ������������������ 메모리����������� ������������������ 누수����������� ������������������ 객체가����������� ������������������ 됨
E가����������� ������������������ B를����������� ������������������ 참조하고����������� ������������������ 있어서����������� ������������������ 참조되지����������� ������������������ 않는����������� ������������������ 객체가����������� ������������������ 되어����������� ������������������ 버림.
A
B
C
D
E
E가����������� ������������������ B를����������� ������������������ 참조를����������� ������������������ 하는데,����������� ������������������ 약한����������� ������������������ 참조를����������� ������������������ 하게����������� ������������������ 된다면?
A
C
D
E
A가����������� ������������������ B를����������� ������������������ 참조하지����������� ������������������ 않게����������� ������������������ 되면
E는����������� ������������������ B를����������� ������������������ 약한참조하기����������� ������������������ 때문에����������� ������������������ B는����������� ������������������ 소멸����������� ������������������ 가능한����������� ������������������ 객체가����������� ������������������ 되고,����������� ������������������ B가����������� ������������������ 참조하는����������� ������������������ C는����������� ������������������ 소멸되고����������� ������������������ 이어����������� ������������������ D,����������� ������������������ E����������� ������������������ 도����������� ������������������ 소멸하게����������� ������������������ 된다.
A
D
E
A가����������� ������������������ B를����������� ������������������ 참조하지����������� ������������������ 않게����������� ������������������ 되면
E는����������� ������������������ B를����������� ������������������ 약한참조하기����������� ������������������ 때문에����������� ������������������ B는����������� ������������������ 소멸����������� ������������������ 가능한����������� ������������������ 객체가����������� ������������������ 되고,����������� ������������������ B가����������� ������������������ 참조하는����������� ������������������ C는����������� ������������������ 소멸되고����������� ������������������ 이어����������� ������������������ D,����������� ������������������ E����������� ������������������ 도����������� ������������������ 소멸하게����������� ������������������ 된다.
A
E
A가����������� ������������������ B를����������� ������������������ 참조하지����������� ������������������ 않게����������� ������������������ 되면
E는����������� ������������������ B를����������� ������������������ 약한참조하기����������� ������������������ 때문에����������� ������������������ B는����������� ������������������ 소멸����������� ������������������ 가능한����������� ������������������ 객체가����������� ������������������ 되고,����������� ������������������ B가����������� ������������������ 참조하는����������� ������������������ C는����������� ������������������ 소멸되고����������� ������������������ 이어����������� ������������������ D,����������� ������������������ E����������� ������������������ 도����������� ������������������ 소멸하게����������� ������������������ 된다.
상호참조����������� ������������������ 객체들이����������� ������������������ 있더라도����������� ������������������ 메모리����������� ������������������ 누수가����������� ������������������ 발생하지����������� ������������������ 않는다.
END