iOS 内存管理 —— MRC & ARC

作者: afishhhhh | 来源:发表于2016-10-13 21:55 被阅读983次

    基本的内存管理规则

    1. 自己生成的对象自己持有
    2. 非自己生成的对象,自己也能持有
    3. 不再需要自己持有的对象时必须释放
    4. 自己不持有的对象无法释放

    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]

    总结一句话:如果调用的方法以 allocnewcopymutableCopy 为前缀,则持有该对象,调用其他的方法不持有该对象,而是将其注册到 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 中的内容,但是既然出了作用域,就不应该再访问其中的内容,因为很有可能该内存块中的内容已经被销毁了。

    我发现我之前说的有点问题,p1Person 对象是具有强引用的,在第二次 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 表示的是弱引用,可以用来避免循环引用。同时 weakassign 又比较相似,两者都表示没有所有权,weak 更多的用来修饰对象,而 assign 一般用来修饰 NSIntegerCGFloatBOOL 等类型。

    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 发送 releaseretain 消息是不会导致引用计数增加或减少的。
    简单讲,一句话,name1 不被 MRC 或者 ARC 影响。

    NSString *name2 = [[NSString alloc] initWithString:name1];
    

    name2 是通过 alloc 方法创建的,所以说我们必须手动 release 它。可以通过 cmd+shift+B 执行一下 Analyze,Xcode 会提示 name2 可能出现了内存泄漏。

    这里有一个情况,打印出 name1name2 的地址,他们的地址是一样的。查阅一下 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
    

    相关文章

      网友评论

        本文标题:iOS 内存管理 —— MRC & ARC

        本文链接:https://www.haomeiwen.com/subject/sdcgyttx.html