ARC与MRC

1.ARC与MRC的概念

ARC: Automatic(自动) Reference(引用) Counting(计数)

什么是自动引用计数?
不需要程序员管理内容, 编译器会在适当的地方自动给我们添加release/retain等代码
注意点: OC中的ARC和java中的垃圾回收机制不太一样, java中的垃圾回收是系统干得, 而OC中的ARC是编译器干得

MRC: Manul(手动) Reference(引用) Counting(计数)

什么是手动引用计数?
所有对象的内容都需要我们手动管理, 需要程序员自己编写release/retain等代码

内存管理的原则就是有加就有减
也就是说, 一次alloc对应一次release, 一次retain对应一次release

 // 只要创建一个对象默认引用计数器的值就是1
        Person *p = [[Person alloc] init];
        
        NSLog(@"retainCount = %lu", [p retainCount]); // 1
        
        // 只要给对象发送一个retain消息, 对象的引用计数器就会+1
        [p retain];
        
        NSLog(@"retainCount = %lu", [p retainCount]); // 2
        
        // 通过指针变量p,给p指向的对象发送一条release消息
        // 只要对象接收到release消息, 引用计数器就会-1
        // 只要一个对象的引用计数器为0, 系统就会释放对象
        [p release];
        // 需要注意的是: release并不代表销毁\回收对象, 仅仅是计数器-1
        NSLog(@"retainCount = %lu", [p retainCount]); // 1
        
        [p release]; // 0

- (void)dealloc
{
    NSLog(@"Person dealloc");
    // 注意:super dealloc一定要写到所有代码的最后
    // 一定要写在dealloc方法的最后面
    [super dealloc];
}

2.野指针和空指针

Person *p = [[Person alloc] init]; // 1
        
        // 只要一个对象被释放了, 我们就称这个对象为 "僵尸对象"
        // 当一个指针指向一个僵尸对象, 我们就称这个指针为野指针
        // 只要给一个野指针发送消息就会报错
        [p release]; // 1-1 = 0
        // *** -[Person release]: message sent to deallocated instance 0x1001146b0

        // 空指针  nil  0
        // 为了避免给野指针发送消息会报错, 一般情况下, 当一个对象被释放后我们会将这个对象的指针设置为空指针
        // 因为在OC中给空指针发送消息是不会报错的
        p = nil;
        
        [p release];

3.多个对象的内存管理

// 当A对象想使用B对象一定要对B对象进行一次retain, 这样才能保证A对象存在B对象就存在, 也就是说这样才能保证无论在什么时候在A对象中都可以使用B对象
// 当A对象释放的时候, 一定要对B对象进行一次release, 这样才能保证A对象释放了, B对象也会随之释放, 避免内存泄露
// 总结一句话: 有增就有减

- (void)setRoom:(Room *)room // room = r
{
    // 只有房间不同才需用release和retain
    if (_room != room) {// 0ffe1 != 0ffe1
        
        // 将以前的房间释放掉 -1
        [_room release];
        
        /*
        // 对房间的引用计数器+1
        [room retain];
        
        _room = room;
         */
        // retain不仅仅会对引用计数器+1, 而且还会返回当前对象
        _room = [room retain];
    }
}

- (Room *)room
{
    return  _room;
}

- (void)dealloc
{
    // 人释放了, 那么房间也需要释放
    [_room release];
    NSLog(@"%s", __func__);
    [super dealloc];
}

4.property修饰符

 readonly: 只会生成getter方法
 readwrite: 既会生成getter也会生成setter, 默认什么都不写就是readwrite

 getter: 可以给生成的getter方法起一个名称
 @property(nonatomic,getter=isOn) BOOL on;
 setter: 可以给生成的setter方法起一个名称

 retain: 就会自动帮我们生成getter/setter方法内存管理的代码
 assign: 不会帮我们生成set方法内存管理的代码, 仅仅只会生成普通的getter/setter方法, 默认什么都不写就是assign
 
 多线程
 atomic ：性能低（默认）
 nonatomic ：性能高
 在iOS开发中99.99%都是写nonatomic

5.@class的用法

1>在.h文件中用@class
    1.如果都在.h中import, 假如A拷贝了B, B拷贝了C ,  如果C被修改了, 那么B和A都需要重新拷贝. 因为C修改了那么B就会重新拷贝, 而B重新拷贝之后相当于B也被修改了, 那么A也需要重新拷贝. 也就是说如果都在.h中拷贝, 只要有间接关系都会重新拷贝
    2.如果在.h中用@class, 在.m中用import, 那么如果一个文件发生了变化, 只有和这个文件有直接关系的那个文件才会重新拷贝
    3.所以在.h中用@class可以提升编译效率
2>两个类相互拷贝
     如果两个类相互拷贝, 例如A拷贝B, B拷贝A, 这样会报错
     如何解决: 在.h中用@class, 在.m中用import
     因为如果.h中都用import, 那么A拷贝B, B又拷贝A, 会形成死循环
     如果在.h中用@class, 那么不会做任何拷贝操作, 而在.m中用import只会拷贝对应的文件, 并不会形成死循环

6.循环引用

如果A对用要拥有B对象, 而B对应又要拥有A对象, 此时会形成循环retain
如何解决这个问题: 不要让A retain B, B retain A
让其中一方不要做retain操作即可

7.自动释放池

 @autoreleasepool { // 创建一个自动释放池
        Person *p = [[Person alloc] init]; // 1
        // 不用关心对象什么时候释放, 只要能够访问p的地方都可以使用p
        p = [p autorelease]; // 只要调用了autorelease, 那么就不用调用release了
        
        [p retain]; // 2
        
        [p run];
    } // 自动释放池销毁了, 给自动释放池中所有的对象发送一条release消息

// 创建一个自动释放池
    // 自动释放池只是将release延迟了而已
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    
    Person *p = [[[Person alloc] init] autorelease];
    [p run];
    
    // 销毁一个自动释放池
    [pool release];

 @autoreleasepool {
     // 1.一定要在自动释放池中调用autorelease, 才会将对象放入自动释放池中
//        Person *p = [[[Person alloc] init] autorelease];
//        [p run];
        
        // 2.在自动释放池中创建了对象, 一定要调用autorelease,才会将对象放入自动释放池中
//        Person *p = [[Person alloc] init];
//        [p run];
        
        // 3.只要在自动释放池中调用autorelease, 就会将对象放入自动释放池
        p = [p autorelease];
        [p run];
    }

// 4.一个程序中可以创建N个自动释放池, 并且自动释放池还可以嵌套
    // 如果存在多个自动释放池的时候, 自动释放池是以 "栈" 的形式存储的
    // 栈的特点: 先进后出
    
    // 给一个对象方法发送一条autorelease消息, 永远会将对象放到栈顶的自动释放池
    @autoreleasepool { // 创建第一个释放池
        @autoreleasepool { // 创建第二个释放池
            @autoreleasepool { // 创建第三个释放池
                Person *p = [[[Person alloc] init] autorelease];
                [p run];
            } // 第三个释放池销毁
            
            Person *p = [[[Person alloc] init] autorelease];
            
        }// 第二个释放池销毁
    }// 第一个释放池销毁
    */

8.ARC

  // ARC的判断准则: 只要没有强指针指向对象, 对象就会释放
        // 默认情况下所有的指针都是强指针
        Person *p = [[Person alloc] init];
        p = nil;
        
        __strong Person *p = [[Person alloc] init];
        // 弱指针
        __weak Person *p2 = p;
       p = nil;
        
        // 在开发中, 千万不要使用一个弱指针保存一个刚刚创建的对象
        // 立即释放
        __weak Person *p = [[Person alloc] init];

9.集合对象的内存管理

       // 1. 如果将一个对象添加到一个数组中, 那么数组会对对象进行一个retain
        Person *p = [Person new];
        NSLog(@"reatinCount = %lu", [p retainCount]);
        NSMutableArray *arrM = [[NSMutableArray alloc] init];
        
        [arrM addObject:p];
        NSLog(@"reatinCount = %lu", [p retainCount]);
        
        [p release];
        NSLog(@"reatinCount = %lu", [p retainCount]);
        // 当数组对象释放之后, 会给数组中所有的对象发送一条release消息
        [arrM release];

10.如何判断当前是ARC还是MRC?

    // 可以在编译的时候判断当前是否是ARC
#if __has_feature(objc_arc)
    NSLog(@"ARC");
#else
    NSLog(@"MRC");
#endif
    return 0;