OC语言 - 内存管理：retain内部实现

retain

1 - Xcode 勾选僵尸模式用来检测野指针。下面一步步验证 retain 的内部实现

// - Student.h

#import <Foundation/Foundation.h>

@interface Student : NSObject{

    NSString   *_name;// 姓名
    NSString   *_sex; // 性别
    NSInteger   _age; // 年龄
}

- (void)sayHI;
- (id)initWithName:(NSString *)name
               sex:(NSString *)sex
               age:(NSInteger )age;

@end

// - Student.m

#import "Student.h"
@implementation Student

-(void)dealloc{

    NSLog(@"%@ 已经销毁",self);
    [super dealloc];
}

- (void)sayHI{
    NSLog(@"I am a student,name ： %@,sex ： %@,age ： %ld",_name,_sex,_age);
}

- (id)initWithName:(NSString *)name sex:(NSString *)sex age:(NSInteger )age{
    
    self = [super init];
    if (self) {
        _name = name;
        _sex = sex;
        _age = age;
    }
    return self;
}

@end

// - MyClass.h

#import <Foundation/Foundation.h>
@class Student;
@interface MyClass : NSObject

// 首先使用 assign 进行测试
@property(nonatomic,assign)Student *stu;

@end

// - MyClass.m

#import "MyClass.h"
@implementation MyClass

- (void)dealloc{

    // 从 TEST ② 开始，解除下行代码注释
    // [_stu release];// 同 self.stu = nil;  因为点语法本质上是走 setter 方法，其内部有执行 [_stu release]

    NSLog(@"%@ 已经销毁",self);
    [super dealloc];
}


// TEST ①：直接赋值
- (void)setStu:(Student *)stu{

    _stu = stu;
}


// TEST ②：赋值时，先把新值 retain 一次
//- (void)setStu:(Student *)stu{
//    _stu = [stu retain];
//}



// TEST ③：先把旧值 release
//- (void)setStu:(Student *)stu{
//
//    // 先进行一次 release
//    [_stu release];
//    _stu = [stu retain];
//}



// 最后处理方式：苹果 retain 特性的默认处理机制
//- (void)setStu:(Student *)stu{
//
//    // 先来一次判定
//    if(_stu != stu){
//
//        // 再进行内存操作
//        [_stu release];
//        _stu = [stu retain];
//    }
//}

@end

// - main.m：分 3 个测试进行验证

#import <Foundation/Foundation.h>
#import "Student.h"
#import "MyClass.h"
int main(int argc, const char * argv[]) {
    
    //------------------------   TEST ①   ----------------------------
    
    // stu01 是实例对象的持有者
    Student *stu01 = [[Student alloc] initWithName:@"Jason" sex:@"female" age:26];// stu01 =  1

    MyClass *class01 = [[MyClass alloc] init];// class01  =  1
    [class01 setStu:stu01];// stu01  =  1
    // 修饰属性使用的是 assign， 所以 class01 的成员变量 _stu 可以获取到 stu01 但并不会拥有它的所有权

    // 根据内存原则：在有 alloc 的地方需进行一次 release 
    [stu01 release];// 触发 dealloc
    // <Student: 0x100606f50> 已经销毁

    // 产生问题
    // 如果 class01 恰恰又在它的某个地方使用了 _stu ，则程序 crash
    // [class01.stu sayHI];// crash

    [class01 release]; // 触发 dealloc
    // <MyClass: 0x100738a40> 已经销毁
    
    
    //------------------------   TEST ②   ----------------------------
    
    //    // 为解决 TEST ① 所产生的问题，我们在给成员变量 _stu 赋值时先进行一次 retain 操作 
    //    Student *stu02 = [[Student alloc] initWithName:@"Jason" sex:@"female" age:26];// stu02  =  1；这里生成的实例对象我们称它是 旧值A
    //    MyClass *class02 = [[MyClass alloc] init];
    //
    //    [class02 setStu:stu02];// 在点语法内部赋值时 stu02 有 retain 处理
    //    NSLog(@"%lu---%lu(%@---%@)",class02.stu.retainCount, stu02.retainCount,class02.stu,stu02);
    //    // 2---2(<Student: 0x100495db0>---<Student: 0x100495db0>)
    //
    //    [stu02 release];// stu02  = 1
    //    // stu02 进行 release 操作，引用计数 -1 并丢失 旧值A 的所用权
    //    // 旧值A 的所有权归 _stu 这个成员变量持有，这也就意味着由它负责释放
    //    // 所以我们会在 dealloc 中我们对成员变量进行一次 release 操作
    //    // 代码执行到这里时 Student 就不会触发 dealloc
    //
    //    NSLog(@"%lu---%lu(%@---%@)",class02.stu.retainCount, stu02.retainCount,class02.stu,stu02);
    //    // 1---1(<Student: 0x100495db0>---<Student: 0x100495db0>)
    //    // 现在我们在别的地方可以愉快地调用，貌似没有什么问题
    //    [class02.stu sayHI];
    //
    //
    //    // 那么问题来了：如果重新赋值的话
    //    Student *stu2A = [[Student alloc] initWithName:@"Lee" sex:@"male" age:33]; // 这里的实例对象我们称它 新值A
    //    NSLog(@"stu02 ：%@   stu2A ：%@",stu02,stu2A);// stu02 ：<Student: 0x100495db0>   stu2A ：<Student: 0x10055e2b0>
    //    [class02 setStu:stu2A];// _stu 原来指向的对象是 旧值A，但是现在 _stu 重新指向了 新值A，就是 stu2A ! 产生内存泄露的问题
    //
    
    //    [class02.stu sayHI];
    //    NSLog(@"%lu---%lu",class02.stu.retainCount,stu2A.retainCount);// 2---2
    //    [stu2A release];// stu2A 放弃 新值A 的持有权；新值A 的所有权归 _stu 所有
    //
    //    [class02 release];// 这里 class02 和 新值A 都会销毁
    //    // <Student: 0x102930850>已经销毁     <MyClass: 0x10042d560>已经销毁
    //    // 但是 旧值A 依然存在于内存之间，因为 MRC 不同于 ARC，ARC 中只要对象没有了所有者的引用，就会自动释放，但时 MRC 不会！
    
    
    //------------------------   TEST ③   ----------------------------
    
    //    // 为解决 TEST ② 所产生的问题，我们在每次赋值前，先把旧值 release 一次，然后再把新值 retain
    //    Student *stu03 = [[Student alloc] initWithName:@"Jason" sex:@"female" age:26];// stu3  =  1    这里生成的实例对象我们称之为 旧值C
    //    MyClass *class03 = [[MyClass alloc] init];// class03  =  1
    //
    //    [class03 setStu:stu03]; // stu03 = 2 
    //    NSLog(@"%lu---%lu",class03.stu.retainCount,stu03.retainCount);// 2---2
    //    [stu03 release];// stu03  =  1
    //
    //    [class03.stu sayHI];
    //
    //    Student *stu3A = [[Student alloc] initWithName:@"Lee" sex:@"male" age:33]; // 新值C
    //    NSLog(@"stu03 的地址：%p   stu3A 的地址：%p",stu03,stu3A);// stu03 的地址：0x10051c7b0   stu3A 的地址：0x100469850
    //
    //    // 重新赋值
    //    [class03 setStu:stu3A];// 点语法中：旧值C 销毁；  新值C 的引用计数+1
    //    [stu3A release];// stu3A =  1
    //    [class03.stu sayHI];
    //
    //    // [class03 release];// <Student: 0x100406780>已经销毁   <MyClass: 0x10069cdc0>已经销毁
    //    // 代码运行到这里，内存泄露问题貌似解决掉了
    //    // 但是！如果我们在 class03 被 release 掉之前，重新赋相同的值呢 ？
    //
    //    // 把上行代码 [class03 release] 屏蔽掉
    //    [class03 setStu:stu3A];// 僵尸对象出现
    //    // 重复赋值时 setter 方法中的 [_stu release] 会把旧值（就是现在的 新值C）release 掉
    //    // 那么 stu3A 已经成了野指针
    //    [class03 release];// <Student: 0x1029127d0>已经销毁    <MyClass: 0x1039a94a0>已经销毁
    //
    //    // 最终解决方案就是把 新、旧 两值进行一次判断后再进行内存操作
    
    return 0;
}

小结

1 - 苹果内部的 retain 实现

// setter
@property(nonatomic,retain)NSString *name; 3 
// 内部实现
- (void)setName:(NSString *)name{
    if(_name != name){
        [_name release];
        _name = [name retain];
        
    }
}

// getter
- (NSString *)name{
    
    return [[_name retain] autorelease];
}