OC语言 - 内存管理：strong | weak | unsafe_unretained | autoreleasing

前言

1 -对 weak 和 strong 描述最多的就是：它们由 ARC 引入，weak 相当于 MRC 中的 assign，但 weak 是用于修饰对象，两者都不会造成引用计数加 1；strong 相当于 MRC 中规定的 retain，它会造成引用计数加 1

2 - strong 指针能够保持对象的生命，一个对象只要有 strong 指针指向它，那么它就不会被释放；相反如果一个没有 strong 指针指向它，那么它将会被自动释放。默认所有实例变量和局部变量都是 stong 指针

3 - weak 型指针变量虽然可以指向一个对象，但不属于对象的拥有者，就是说当对象被销毁时，这个 weak 指针也就自动指向 nil

strong

1 - 如果硬是要在 MRC 环境下使用 strong，它和 retain 并没有什么区别

@property(strong,nonatomic)NSMutableArray *arrayI;
@property(strong,nonatomic)NSMutableArray *arrayII;

① 测试一：使用点语法置 nil | 直接使成员变量置 nil 

    self.arrayI = [[NSMutableArray alloc] init];
    NSLog(@"%ld     %ld-----%p    %p",self.arrayI.retainCount,_arrayI.retainCount,self.arrayI,_arrayI);
    // 2     2-----0x10074e660    0x10074e660
    // _arrayI --> arrayI
    

    self.arrayII = self.arrayI;
    NSLog(@"%ld     %ld-----%p    %p",self.arrayII.retainCount,_arrayII.retainCount,self.arrayII,_arrayII);
    // 3     3-----0x10074e660    0x10074e660
    // _arrayII --> arrayI
    

    self.arrayI = self.arrayII;
    NSLog(@"%ld     %ld-----%p    %p",self.arrayI.retainCount,_arrayI.retainCount,self.arrayI,_arrayI);
    // 3     3-----0x10074e660    0x10074e660

    
//    // 验证一：直接 release
//    _arrayI = nil;
//    NSLog(@"self.arrayI：%ld %ld %p",self.arrayI.count,_arrayI.count,self.arrayI); // 0  0  0x0
//    // 猜一猜会输出什么 ？
//    NSLog(@"self.arrayII：%p   %ld",_arrayII,_arrayII.retainCount); //0x10074e660   3
    
    
    // 验证二：使用点语法
    self.arrayI = nil; // 使用点语法 _arrayI 会先进行 release 一次（这就是下行代码会输出 2 的原因），然后再置 nil
    NSLog(@"self.arrayI：%ld %ld %p",self.arrayI.count,_arrayI.count,self.arrayI); // 0  0  0x0
    // 猜一猜又会输出什么 ？
    NSLog(@"self.arrayII：%p   %ld",_arrayII,_arrayII.retainCount); //0x10074e660   2

② 测试二：直接赋值

    self.arrayI = [[NSMutableArray alloc] init];

    NSLog(@"self.arrayI：%p",self.arrayI); // 0x10066b830
    NSLog(@"%ld     %ld",self.arrayI.retainCount,_arrayI.retainCount);// 2    2


    // 直接赋值
    _arrayII = self.arrayI;
    NSLog(@"%ld     %ld",self.arrayII.retainCount,_arrayII.retainCount);// 2    2
    NSLog(@"%p     %p",self.arrayI,_arrayII); // 0x10066b830     0x10066b830


    self.arrayI = nil;
    NSLog(@"self.arrayI：%p",self.arrayI);// 0x0
    NSLog(@"%ld",self.arrayII.retainCount);// 1
    NSLog(@"self.arrayII：%p",self.arrayII);// 0x10066b830

2 - ARC 环境中的 strong

    // abcName 作为 @"natsu" 的最初持有者，是 @"natsu" 对象的 Strong reference
    NSString *abcName = [[NSString alloc] initWithString:@"natsu"];

    // abcName 赋值给 xyzName，则 xyzName 同样是 @"natsu" 对象的 Strong reference
    NSString *xyzName = abcName;

    // abcName 重新指向了新的内容
    abcName = [[NSString alloc] initWithString:@"mark"];
    // 此时 abcName 抛弃 @"natsu" 对象，成为 @"mark" 对象的持有者
    // 而 @"natsu" 对象持有者只剩下 xyzName
    // 所以，@"natsu" 和 @"mark 两个对象都存在内存之中

    
    // otherName 是 @"mark" 对象的持有者
    NSString *otherName = abcName;

    // xyzName 是 @"mark" 对象的持有者
    xyzName = otherName;// @"natsu" 对象已经没有持有者了，系统会自动把它抛弃

weak

1 - MRC 环境中是不能使用 weak 来修饰对象和基本数据类型，该概念是从 iOS 5 / Mac OS X 10.7 开始导入的。weak 修饰的属性一旦释放了内存，其指针将自动被赋值为 nil（有效防止野指针）。它可以防止循环引用，比如 delegate 和 controller 之间，视图控制器通过 strong 指针 self.view 拥有一个 tableview，但是 tableview 的 delegate 和 datasource 都是 weak 指针，指向你的 controller

    NSString *name = @"小跳蛙";
    __weak  NSString *newName = name;
    NSLog(@"%p    %p",name,newName);// 0x100001070    0x100001070
    name = nil;// 小跳蛙 这个对象被释放
    NSLog(@"%p",newName);// newName 立即指向 nil

    __weak NSString *pleaFrog = [[NSString alloc] initWithFormat:@"快乐蛙"];// pleaFrog 是 weak 指针修饰的，它不持有对象，所以对象创建出来之后就立马被释放

// strongName --->  @"natsu"
NSString *strongName = [[NSString alloc] initWithString:@"natsu"];3
// weakName ---> @"natsu"
__weak NSString *weakName = strongName;// weakName 可以拿到 natsu 对象，但并不是其持有者

// strongName --->  @"mark"
strongName = [[NSString alloc] initWithString:@"mark"];// 此时 natsu 对象便没有了持有者，即被抛弃。同时，weakName 置 nil

unsafe_unretained

1 - 在没有引入 weak 之前采用的是 unsafe_unretained。它和 weak 相似，不同点就是当指针指向的对象被释放时，并不会为其指针自动置 nil，也就形成了野指针

注：尽量避免 unsafe_unretained 使用

@property(strong,nonatomic)NSMutableArray *arrayI;
@property(unsafe_unretained,nonatomic)NSMutableArray *arrayII;

self.arrayI = [[NSMutableArray alloc] init];
self.arrayII = self.arrayI;
self.arrayI = nil;// 一旦 arrayI 将内存释放掉，但是 self.arrayII 并不知情，依旧保留着原来的内存地址，接下来的事情，就是 crash
NSLog(@"self.arryyII:%p",self.arrayII);// 崩溃

autoreleasing

1 - 该关键字使对象延迟释放，相当于 MRC 中的 Autorelease：比如自己想要把一个未初始化的对象引用到另一个方法当中，那么这种情况就可以使用 autoreleasing

-(void)performTestI{
    NSError *error = nil;
    [self generateErrorInVariable:&error];
    NSLog(@"Error：%@",error);// 这里就可以使用该方法外创建的实例对象，同样适合谁分配谁释放的原则

}

-(void)generateErrorInVariable:(__autoreleasing NSError **)paramError{

    *paramError = [[NSError alloc] initWithDomain:@"myAPP" code:1 userInfo:nil];
    
}

2 - 如果方法的返回值是在自身方法中申请的，那么希望释放是在调用端中进行的话，往往需要在该方法内做以下处理

- (NSString *)stringAutorelease{
    
    // MRC
    NSString *strMRC = [[NSString alloc] initWithFormat:@"stringTest"];
    return [[strMRC retain] autorelease];

    // ARC
    __autoreleasing NSString *strARC = [[NSString alloc] initWithFormat:@"stringTest"];
    return strARC;
}

ARC 环境下的 strong、weak、unsafe_unretained

1 - 代码示例

// - person.m

#import "Person.h"
@implementation Person
-(void)dealloc{
    
    NSLog(@"%@已销毁",self);
}


// 作用域一
-(void)testOne{
    

    __weak Person *weakPerson;
    __unsafe_unretained Person *unsafePerson;
    __strong Person *strongPerson;
    
    
    NSLog(@"111111111");
    
    // 作用域二
    {
        
        // weakPerson 出了作用域二，立即销毁并自动置 nil
        weakPerson = [Person new];// 0x10062d530
        
        // unsafePerson 出了作用域二，立即销毁但并不会置 nil，成为野指针
        unsafePerson = [Person new];// 0x10320c200
        
        // strongPerson 出了方法（作用域一）后销毁
        strongPerson = [Person new]; // 0x10052afd0
        
    }
    NSLog(@"weakPerson = %@",weakPerson);     // (null)
    NSLog(@"unsafePerson = %@",unsafePerson); // 野指针：依旧指向原地址 0x10320c200
    NSLog(@"strongPerson = %@",strongPerson); // 0x10052afd0
    
    NSLog(@"999999999");
    
    // weakPerson 和 unsafePerson 出了作用域二即刻销毁，在 NSLog(@"111111111") 和 NSLog(@"999999999") 之间执行
    // strongPerson 和 main 函数中的 p1，两者的 dealloc 在 NSLog(@"999999999") 执行完毕之后
    
}

@end

// - main.m

#import <Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
    
    Person *p1 = [Person new];// 0x10301b4f0
    [p performSelector:@selector(testOne)];
    // 执行完 testOne 方法后 p1 自动销毁
    return 0;
    
}

日志信息

小结：ARC 环境中的内存管理

1 - ARC 只能工作于 OC 对象，如果应用了 core foundation 或者 malloc()/free() 还是要自己手动管理内存的

2 - 不能使用 NSAutoreleasePool 对象，要使用 @autoreleasepool 块来代替它

3 - 不能使用内存存储区 NSZone

4 - 声明 IBOutlet 时一般使用 weak，除了对 StoryBoard 这样 nib 中间的顶层对象要用 strong

5 - copy 和之前 MRC 环境下的 copy 一样，有深拷贝、浅拷贝之分