ios 内存管理

引用计数式内存管理方式

• 自己生成的对象，自己所持有
• 非自己生成的对象，自己也能持有
• 不再需要自己持有的对象时释放
• 非自己持有的对象无法释放

关键词：“生成”，“持有”，“释放”，“废弃”

对象操作	Objective-C 方法
生成并持有对象	alloc/new/copy/mutableCopy 等方法
持有对象	retain 方法
释放对象	release 方法
废弃对象	dealloc 方法

*注意：这些有关Objective-C 内存管理的方法，实际上不包括在语言中，而是包含在Cocoa 框架中用于 OS X、iOS应用开发。Cocoa 框架中Foundation 框架类库的NSObject 类担负内存管理的职责 *

自己生成的对象，自己所持有

• alloc
• new
• copy
• mutableCopy

对“自己”一词的理解，可以解释”对象的使用环境“，或者理解为程序猿“本身”

/*
  * 自己生成并持有对象
*/
id obj = [NSObject alloc] init];
/*
  * 自己持有对象
*/

非自己生成的对象，自己也能持有

使用上述方法以外取得的对象，因为非自己生成持有，所以自己不是该对象的持有者

/*
  * 取得非自己生成并持有的对象
*/
id obj = [NSMutableArray array];
/*
  * 取得对象的存在，但自己并不持有对象
*/
[obj retain];
/*
  * 自己持有对象
*/

不再需要自己持有的对象时释放

/*
  * 自己生成并持有对象
*/
id obj = [NSObject alloc] init];
/*
  * 自己持有对象
*/
[obj release];
/*
 *   释放对象
 *   指针仍然保留在变量obj中，但是对象一经释放绝对不可访问
*/

/*
  * 自己生成并持有对象
*/
id obj = [NSObject alloc] init];
/*
  * 自己持有对象
*/
[obj autorelease];
/*
 *   取得对象的存在，但是自己不持有该对象
*/
[obj retain];
/*
  * 自己持有对象
*/
[obj release];
/*
 *   释放对象
 *   指针仍然保留在变量obj中，但是对象一经释放绝对不可访问
*/

** release是立即释放的，autorelease是延迟释放 **

无法释放非自己持有的对象

/*
  * 自己生成并持有对象
*/
id obj = [NSObject alloc] init];
/*
  * 自己持有对象
*/
[obj release];
/*
  *  对象已经释放
*/
[obj release];
/*
  *  释放之后再次释放已非自己持有的对象
  *  应用程序崩溃
*/

autorelease

自动释放，看起来感觉很像ARC

1. 生成并持有NSAutoreleasePool对象
2. 调用已分配对象的 autorelease 实例方法
3. 废弃NSAutoreleasePool 对象

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
id obj = [[NSObject alloc] init];
[obj autorelease];
[pool drain];

ARC 出现了

ARC有效时候，其类型必须附加所有权修饰符，所以修饰符一共有4种

• __strong
• __weak
• __unsafe_unretained
• __autoreleasing

__strong 修饰符

id 类型 和对象类型默认的所有权修饰符

id obj = [NSObject alloc] init]; 
// 等同于
id __strong obj = [NSObject alloc] init];
/* ARC无效的情况下 */
{
  id obj = [NSObject alloc] init]; 
  [obj release];
}

/*
 附有__strong 修饰符的变量obj 在其超出变量的作用域后，及该变量被废弃的时候，会释放其被赋予的对象NSObject 
*/

__weak 修饰符

单单通过__strong 修饰符编译器进行内存管理，还是不能解决有些重大的问题。例如“循环引用”

@interface Test : NSObject
{
    id __strong _obj;
}

- (void)setObject:(id __strong)object;

@end
@implementation Test

- (instancetype)init
{
    self = [super init];
    if (self) {
        
    }
    return self;
}

- (void)setObject:(id __strong)object
{
    _obj = object;
}

- (void)dealloc
{
    NSLog(@"正常释放了");
}

@end

- (void)test{

    Test *test0 = [[Test alloc] init];
    Test *test1 = [[Test alloc] init];
    
    NSLog(@"%@", test0);
    NSLog(@"%@", test1);
    
    test0 = nil;
    test1 = nil;
    
    NSLog(@"%@", test0);
    NSLog(@"%@", test1);
}
/*
    打印结果
    2017-05-19 16:14:22.115152 ios内存管理[14156:2305168] <Test: 0x1740170a0>
    2017-05-19 16:14:22.115270 ios内存管理[14156:2305168] <Test: 0x1740170b0>
    2017-05-19 16:14:24.304241 ios内存管理[14156:2305168] 正常释放了
    2017-05-19 16:14:25.107007 ios内存管理[14156:2305168] 正常释放了
    2017-05-19 16:14:25.107290 ios内存管理[14156:2305168] (null)
    2017-05-19 16:14:25.107454 ios内存管理[14156:2305168] (null)

    正常释放
*/

- (void)test{

    Test *test0 = [[Test alloc] init];
    Test *test1 = [[Test alloc] init];
    
    [test0 setObject:test1];
    [test1 setObject:test0];

    NSLog(@"%@", test0);
    NSLog(@"%@", test1);
    
    test0 = nil;
    test1 = nil;
    
    NSLog(@"%@", test0);
    NSLog(@"%@", test1);
}
/*
  打印结果
  2017-05-19 16:18:33.019380 ios内存管理[14162:2306012] <Test: 0x17400a000>
  2017-05-19 16:18:33.019495 ios内存管理[14162:2306012] <Test: 0x17400a010>
  2017-05-19 16:18:33.019544 ios内存管理[14162:2306012] (null)
  2017-05-19 16:18:33.019589 ios内存管理[14162:2306012] (null)

  此时没有正常释放
*/

1.当nil被赋予了test0， test0对Test对象A的强引用失效，Test对象A的所有者不存在了，因此要废弃Test对象A
2.当nil被赋予了test1， test1对Test对象B的强引用失效，Test对象B的所有者不存在了，因此要废弃Test对象B
3.但是此时，Test对象A还被Test对象B的成员变量_obj 所持有
4.但是此时，Test对象B还被Test对象A的成员变量_obj所持有
所以，因为循环引用无法正常释放，导致了内存泄漏

这个时候__weak 修饰符就派上用场了

个人理解：对象A被 用 __weak修饰的变量b所持有，当对象A不再被其他变量强引用着，对象A会直接被释放

{
   id __strong obj0 = [[NSObject alloc] init];
   /*
      obj0 变量为强引用
    */
    id __weak obj1 = obj0;
/*
      obj1 变量持有生成对象的弱引用
    */
}
/*
  obj0 变量超出其作用域，强引用失效，所以自动释放自己持有的对象
  因为对象的所有者不再存在，所以废弃该对象
*/

前面的对象Test的成员变量 _obj 用__weak 修饰，这样就可避免循环引用

// 定义一个全局变量
// id __weak obj1;

- (void)test1
{
    obj1 = nil;
    Test __strong *test0 = [[Test alloc] init];
    obj1 = test0;

    NSLog(@"%@", test0);
    NSLog(@"%@", test0);
}
NSLog(@"obj1 : %@", obj1);
/*
打印结果
2017-05-19 17:25:31.042324 ios内存管理[14237:2319832] <Test: 0x174003dd0>
2017-05-19 17:25:31.042444 ios内存管理[14237:2319832] <Test: 0x174003dd0>
2017-05-19 17:25:31.042537 ios内存管理[14237:2319832] 正常释放了
2017-05-19 17:25:31.042613 ios内存管理[14237:2319832] obj1 : (null)
*/
/*
obj0 变量超出其作用域，强引用失效，所以自动释放自己持有的对象，因为对象的所有者不再存在，所以废弃该对象
在废弃对象的同时，obj1变量的弱引用失效，nil赋值给obj1
*/

__unsafe_unretained修饰符

最不安全的修饰符，
它和__weak 修饰符号一样都是不能自己生成并持有对象，因为会立即释放。但是用__strong修饰符的变量赋值给他，要确保该赋值的对象确实的存在，不然会变成被废弃的（悬垂指针）

__autoreleasing 修饰符

{
   @autoreleasepool {
        /*
            取得非自己生成并持有的对象
         */
        id __strong obj = [NSMutableArray array];
        /*
            因为变量obj为强引用，
            所以自己持有对象
         
            并且该对象
            由编译器判断其方法名后
            自动注册到autoreleasepool中
         */
    }
        /*
            变量obj在超出其作用域后，强引用失效，自动会释放对象，
            随着@autoreleasepool块的结束，所有注册到@autoreleasepool中的对象被释放，
            对象的所有者不存在，所以废弃对象
         */
}

在访问附有 __weak 修饰符的变量必须访问注册到 @autoreleaspool的对象！！！！这是因为__weak修饰符只持有对象的弱引用，在访问对象的过程中，该对象随时有可能被废弃，如果把要访问的对象注册到@autoreleaspool中，那么在@autoreleaspool块结束之前都能确保对象的存在。

ARC 的过程