基本的内存管理规则
- 自己生成的对象自己持有
- 非自己生成的对象,自己也能持有
- 不再需要自己持有的对象时必须释放
- 自己不持有的对象无法释放
MRC
1. 自己生成的对象自己持有
如果调用的方法以 alloc、new、copy、mutableCopy 等开头,则生成的对象自己持有。自己是谁?自己就是该方法的使用者。
以下是栗子:
{
Person *p1 = [[Person alloc] init];
...
[p1 release];
}
通过 alloc
生成的对象,被 p1
持有,当 p1
不再需要持有该对象时则释放它。如果不释放它,出了作用域就再也访问不到该对象了,也就造成了内存泄漏。
2. 非自己生成的对象,自己也能持有
除了上述提到的四种前缀,通过其他方法创建的对象,都不被自己所持有。
假定 Person
类中有以下方法:
+ (instancetype)object {
id p = [[Person alloc] init];
return p;
}
根据命名规则,object
的语义是使用者取得该对象,但不持有。所以使用者会这样调用该方法:
Person *p1 = [Person object];
// 一句话结束,因为使用者认为我不持有该对象,何必release
但我们看到 object
方法中的代码可以发现,p1
其实是持有了该对象(后文有一个 allocObject
方法就是这样),这样一来就造成了内存泄漏。
那好,在 return p
之前加上 [p release]
呢,如果是这样的话 return p
真的是有个p用。
我自己曾经这样想,那我可以在方法外释放呀。因为我忽略了一点,这种方法一般都是对使用者隐藏细节的,所以除了我只有鬼会像下面这样写。
Person *p = [Person object];
[p release];
那么正确的 object
方法应该是这样的:
+ (instancetype)object {
id p = [[Person alloc] init];
[p autoreleasepool];
return p;
}
将 p
注册到自动释放池,一旦自动释放池的作用域结束 p
也就释放了。
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
Person *p = [Person object];
[pool drain];
// Person对象被释放
回顾下第一条规则,再举个栗子,如果有一个 allocObject
方法:
+ (instancetype)allocObject {
id p = [[Person alloc] init];
return p;
}
在这个方法中没有使用 [p autoreleasepool]
,因为根据命名规则,allocObject
方法表述的意思是,我创建该对象并持有它。所以使用者会 Person *p = [Person allocObject]
创建对象,当不再需要它的时候 [p release]
。
总结一句话:如果调用的方法以 alloc
、new
、copy
、mutableCopy
为前缀,则持有该对象,调用其他的方法不持有该对象,而是将其注册到 autoreleasepool
。
3. 不再需要自己持有的对象时必须释放
NSObject
类中有一个 dealloc
方法,当对象的引用计数为0时,该方法会自动被调用,用于释放该对象的内存。如果重写该方法,必须在最后写上 [super dealloc]
。
除了上文说到的自己生成并持有的对象需要自己释放,还有另一个栗子:
Person *p = [Person object];
// 根据之前的代码,p 不持有 Person 对象
[p retain];
// p 持有该对象了
[p release];
// 释放对象
4. 自己不持有的对象无法释放
Person *p = [[Person alloc] init];
[p release];
[p release];
第一次 release
的时候已经不持有该对象了,第二次也就没啥用。
从书上看到说这样会造成程序崩溃,但是好像并没有,只有控制台输出了一句话:重复 release
。
另一个栗子:
@autoreleasepool {
Person *p1 = [Person object];
[p1 release];
}
按照道理来说,p1
不持有对象,应该不能调用 release
才对,可是上面的代码运行起来也没什么错误。
不知道大神们怎么看。
5. 关于 AutoreleasePool
AutoreleasePool
可以起到一种延时销毁的作用,当 AutoreleasePool
的作用域结束之后,在 AutoreleasePool
中注册的对象会收到 release
的消息,随后将对象销毁。
ARC
ARC 会在编译期添加合适的内存管理的相关代码,但从本质上讲,它与 MRC 还是无异的。
1. 自己生成的对象自己持有
首先,在 ARC 中引入了__strong
修饰符(下文还会提到),是所有 id
类型和对象类型默认的修饰符,以下两条语句是等价的:
{
id obj = [[NSObject alloc] init];
// id __strong obj = [[NSObject alloc] init];
}
当 obj
出了作用域之后,对 NSObject
对象的强引用消失,该对象则被自动销毁。以上代码在 MRC 中相当于:
{
id obj = [[NSObject alloc] init];
[obj release];
}
上个栗子是针对内存管理的第一条规则,自己生成并持有的对象,在 ARC 模式下自动被释放。
2. 非自己生成的对象,自己也能持有
// ARC 模式下:
@autoreleasepool {
Person *p1 = [Person object];
...
}
+ (instancetype)object {
Person *p = [[self alloc] init];
return p;
}
ARC 会自动在 return p
之前插入 [p autorelease]
。p1
默认具有强引用,当出了 autoreleasepool
的作用域之后,p1
的强引用失效,该对象被释放。以上代码应该等价于 MRC 模式下的以下代码:
@autoreleasepool {
Person *p1 = [Person object];
[p1 retain];
...
[p1 release];
}
+ (instancetype)object {
Person *p = [[self alloc] init];
[p autorelease];
return p;
}
3. __weak
修饰符和 __strong
修饰符
有以下代码:
Person *__weak p1;
NSLog(@"%@", p1);
@autoreleasepool {
Person *p2 = [Person object];
p1 = p2;
NSLog(@"%@", p1);
}
NSLog(@"%@", p1);
运行以上代码可以发现,当 p1
弱引用的对象被销毁后,p1
被自动置为 nil
。但是反观 __strong
修饰符:
Person *p1;
@autoreleasepool {
p1 = [Person object];
NSLog(@"%@", p1);
}
NSLog(@"%@", p1);
出了 autoreleasepool
的作用域之后,p1
并没有被置为 nil
,而且还可以访问到 p1
中的内容,但是既然出了作用域,就不应该再访问其中的内容,因为很有可能该内存块中的内容已经被销毁了。
我发现我之前说的有点问题,p1
对 Person
对象是具有强引用的,在第二次 NSLog(p1)
的时候,p1
的强引用并没有失效,当然是可以继续访问 p1
的。
4. 循环引用
循环引用有两种情况:第一种是对象之间的互相强引用,第二种是对象自身的强引用。
- 首先是第一种情况,举个李子:
// Person.h
@interface Person : NSObject
@property (nonatomic, strong) Person *child;
@end
// Person.m
@implementation Person
- (void)dealloc {
NSLog(@"person dealloc");
}
- (instancetype)init {
self = [super init];
if (self) {
}
return self;
}
@end
// main.m
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *p1 = [[Person alloc] init];
Person *p2 = [[Person alloc] init];
p1.child = p2;
p2.child = p1;
}
return 0;
}
我们看到 p1.child
强引用了 p2
,而 p2.child
强引用了 p1
,这样就造成了循环引用,运行之后是不会打印出 person dealloc
信息的。但是这个情况完全可以主动断开这个循环强引用,比如将 p1.child
置为 nil
,因为我们很明确这里存在循环引用。
- 接下来是第二种情况,自身强引用:
// main.m
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *p1 = [[Person alloc] init];
p1.child = p1;
}
return 0;
}
同样只要 p1.child = nil
即可。
以上的例子还是很直观的,主动断开循环引用不会有什么问题,不过更普遍的方法应该是使用 weak
修饰符,比如写 delegate
的时候就会这样写:
@property (nonatomic, weak) id<SomeDelegate> delegate;
提到 delegate
,有一点,在 MRC 时代,delegate
是使用 assign
修饰的。那时候需要在 dealloc
中将 delegate
置空,不然会存在悬空指针,而现在使用 weak
会自动赋值为 nil
。
属性
1. 内存管理语义 —— retain
& strong
在没有引入 ARC 之前,属性用 retain
修饰表示持有,相当于上文提到的在 MRC 中使用 [p retain]
表示持有。
上代码:
// Person.h
@interface Person : NSObject
@property (nonatomic, retain) Person *child;
@end
// Person.m
@implementation Person
@synthesize child = _child;
- (Person *)child {
return _child;
}
- (void)setChild:(Person *)child {
[child retain];
[_child release];
_child = child;
}
@end
被 retain
修饰的属性在它的 set
方法中会持有新的值,释放旧的值。然后在 ARC 的环境下,一般是使用 strong
来替换 retain
,但是他们的作用是一样的,而且 strong
是默认的修饰符(上文也有提到)。如果写了以下代码:
Person *p1 = [Person new];
Person *p2 = [Person new];
p1.child = p2;
// 此时 p2 和 p1.child 同时持有 person 对象
[p2 release];
// 只有 p1.child 持有 person 对象
2. 内存管理语义 —— assign
// 只列出了需要修改的代码
// Person.h
@property (nonatomic, assign) Person *child;
// Person.m
- (Person *)child {
return _child;
}
- (void)setChild:(Person *)child {
_child = child;
}
可以看到 set
方法与之前的 retain
不同,仅仅是简单的赋值操作,也就是说 child
是不持有新值的。如果写了以下代码:
Person *p1 = [Person new];
Person *p2 = [Person new];
p1.child = p2;
// 只有 p2 持有 person 对象
[p2 release];
执行最后一条语句之后 p2
就被释放了,如果你这时候写了一条 NSLog(@"%@", p1.child)
,只会得到 EXC_BAD_ACCESS。
3. 内存管理语义 —— weak
weak
也是在 ARC 时代引入的,与 strong
相反,weak
表示的是弱引用,可以用来避免循环引用。同时 weak
和 assign
又比较相似,两者都表示没有所有权,weak
更多的用来修饰对象,而 assign
一般用来修饰 NSInteger
、CGFloat
、BOOL
等类型。
MRC 和 ARC 下的 dealloc
方法
当一个对象没有持有者的时候,
dealloc
方法会自动地被调用,用于清除该对象所持有的资源,包括该对象中那些存储了 Objective-C 对象的实例变量。
// 以下是 MRC 模式下的一个栗子:
@interface Person : NSObject
@property (nonatomic, retain) NSString *name;
@end
@implementation Person
- (void)dealloc {
[_name release];
_name = nil;
// 在初始化 Person 对象的时候,你可能对 name 执行了 new 操作,在这里将其释放,随后将 _name 置为 nil。
[super dealloc];
// 在 MRC 的模式下,必须在方法的最后调用父类的 dealloc 方法
}
@end
// 以下是 ARC 模式下的一个栗子,直接写不一样的 dealloc 方法:
- (void)dealloc {
// 释放一些非 Objc 的对象
}
// 所以在 ARC 模式下,基本上不需要重写 dealloc 方法,但是我在自己写代码的过程中,我一般还是会写下 dealloc 方法,但只是在其中 NSLog 一下,看看该对象最后有没有被释放,仅此而已,然后就把它删除了。
其他的一些问题
1. 关于字符串的内存管理(MRC):
NSString *name1 = @"abc";
以@
标记创建的字符串都是字符串常量,存储在静态存储区(常量区)而不是在堆内存。其实类似于 C 语言中的 char *name = "abc"
,也将是说 name1
在编译期就已经分配好内存空间,指向 abc
的常量地址,在程序的整个生命周期中都存在,向 name1
发送 release
、retain
消息是不会导致引用计数增加或减少的。
简单讲,一句话,name1
不被 MRC 或者 ARC 影响。
NSString *name2 = [[NSString alloc] initWithString:name1];
name2
是通过 alloc
方法创建的,所以说我们必须手动 release
它。可以通过 cmd+shift+B
执行一下 Analyze,Xcode 会提示 name2
可能出现了内存泄漏。
这里有一个情况,打印出 name1
和 name2
的地址,他们的地址是一样的。查阅一下 Apple 的文档,其中关于 initWithString
的解释:
Returns an NSString object initialized by copying the characters from another given string.
我想在这里的情况应该是,initWithString
直接返回字符串常量的地址,而不是重新开辟一块内存空间。不过我们还是应该遵循内存管理的原则,release
一下 name2
。
同样的,以下的情况也应该遵循内存管理的规则:
NSString *name4 = [otherString copy];
// copy 可能会产生一个副本被 name4 持有
NSString *name4 = [NSString stringWithString:name];
// name4 不持有 NSString 对象,不需要 release
网友评论