自动引用计数和@autoreleasepool

1、[NSObject alloc]在创建完对象后，会让该对象的retainCount+1，后续的init为初始化该对象属性的函数。
若alloc成功后，不把该地址引用赋值给某个指针变量NSObject *obj，则该新创建的对象的引用计数始终为1。
则整个程序运行的声明周期内，该内存都不会被回收，malloc、new也是同样的道理，所以会引起内存泄露。

2、ARC下虽然不能直接调用retainCount查看引用计数，但也可以通过以下几种方式work round。

方法一：[obj valueForKey:@"retainCount"];
这个方法测了一下经常不准，但好处是在引用计数==0，obj被回收以后不会报错，另外两种会报错。

方法二：OBJC_EXTERN int _objc_rootRetainCount(id);
_objc_rootRetainCount(obj);

方法三：CFGetRetainCount((__bridge CFTypeRef)obj);

============================================

关于autoreleasepool

自动释放池是NSAutoreleasePool的实例，其中包含了收到autorelease消息的对象。当一个自动释放池自身被销毁（dealloc）时，它会给池中每一个对象发送一个release消息。
如果你给一个对象多次发送autorelease消息，那么当自动释放池销毁时，这个对象也会收到同样数目的release消息。
需要注意的是：如果在delloc里面没有调用[super delloc]，这样做没有问题，只是delloc被多次调用。但如果有[super delloc]，则第二次重复调用会产生exc_bad_access或者signal sigabrt。所以还是不要在一个autoreleasepool里对同一个对象做一次以上的autorelease函数调用，何况这么做没有任何意义。
可以看出，一个自动释放的对象，它至少能够存活到自动释放池销毁的时候。这样看来它是一种延迟释放机制，这样保证局部堆上的变量能够被外部正常使用。

以下写法也是一样生效的：

NSObject *obj = [NSObject new];
@autoreleasepool{
    [obj autorelease];
// 1. [obj release];
// 2. [obj retain];
}
// 到这里的时候obj就被释放了

可见并不是必须在alloc的时候调用autorelease，也不是必须在@autoreleasepool内部调用alloc创建对象，总之只要是在@autoreleasepool内部调用过autorelease的对象，都会在@autoreleasepool作用域结束的时候调用release，仅此而已。
如果在注释1的位置直接调用release，那么obj会因为retainCount==0立刻被回收，而不会等到autoreleasepool作用域结束，虽然在那是又执行一遍release，但是没有意义了。
如果在注释2的位置再次调用retain，那么就是到autoreleasepool作用域结束调用一次release，那么因为retainCount==1, obj对象引用的内存还是不会回收，要么在调用一次release，要么再调用一次autorelease。
也就是说，alloc/new/copy/retain是一组增加retainCount的，release和autoRelease是一组减少retainCount的，要释放内存第一组和第二组的调用次数要完全一致。

小结：

只有在自动释放池中调用了对象的autorelease方法,这个对象才会被存储到这个自动释放池之中.
如果只是将对象的创建代码写在自动释放之中,而没有调用对象的autorelease方法.是不会将这个对象存储到这个自动释放池之中的.
对象的创建可以在自动释放池的外面,在自动释放池之中,调用对象的autorelease方法,就可以将这个对象存储到这个自动释放池之中.
如果对象的autorelease方法的调用放在自动释放池的外面,是无法将其存储的这个自动释放池之中的.
autorelease 的调用只有放在自动释放池之中才可以讲其存储到自动释放池之中, 对象的创建可以在外面
当自动释放池结束的时候.仅仅是对存储在自动释放池中的对象发送1条release消息而不是销毁对象.
如果在自动释放池中,调用同1个对象的autorelease方法多次.就会将对象存储多次到自动释放池之中.
在自动释放池结束的时候.会为对象发送多条release消息.
所以,1个自动释放池之中,只autorelease1次,只将这个对象放1次, 否则就会出现野指针错误.
如果在自动释放池中,调用了存储到自动释放中的对象的release方法.
在自动释放池结束的时候,还会再调用对象的release方法.
这个时候就有有可能会造成野指针操作.
将对象存储到自动释放池,并不会使对象的引用计数器+1 所以其好处就是:创建对象将对象存储在自动释放池,就不需要在写个release了.
自动释放池可以嵌套.
调用对象的autorelease方法,会讲对象加入到当前自动释放池之中
只有在当前自动释放池结束的时候才会像对象发送release消息.

============================================

在创建对象的时候，调用autorelease，就能将该对象放到autoreleasepool中。利用autoreleasepool的延迟释放来管理内存。autoreleasepool这么重要，可是我们在实际开发中并没有手动创建autoreleasepool，却没有内存泄露。这是为什么呢？其实没有手动创建并不代表它不会被创建，那么它是什么时候创建的呢？

iOS程序默认在main函数中会加入@autoreleasepool，但这个基本没什么用，因为它的作用域是整个main函数结束，也就是说延迟release的时间点是程序退出之前，那么既然程序都退出了，所有资源和内存都已经被操作系统回收了，还释放个什么劲啊？

所以实际上iOS程序在运行过程中，远不止我们自己实现的代码里会添加@autoreleasepool，autoreleasepool的数据存储结构是一个嵌套结构，也就是说可以在一个autoreleasepool内部嵌套另一个autoreleasepool并且可以无限嵌套下去。这有点类似函数的栈变量压栈和出栈的逻辑。所以runtime自动调用和创建的autoreleasepool对程序开发者来说基本是透明的。

App启动后，系统在主线程runLoop里注册两个Observser,其回调都是_wrapRunLoopWithAutoreleasePoolHandler()。第一个 Observer 监视的事件是 Entry(即将进入Loop)，其回调内会调用 _objc_autoreleasePoolPush() 创建自动释放池。其优先级最高，保证创建释放池发生在其他所有回调之前。第二个 Observer 监视了两个事件： BeforeWaiting(准备进入休眠) 时调用_objc_autoreleasePoolPop() 和 _objc_autoreleasePoolPush() 释放旧的池并创建新池；Exit(即将退出Loop) 时调用 _objc_autoreleasePoolPop() 来释放自动释放池。这个 Observer 优先级最低，保证其释放池子发生在其他所有回调之后。在主线程执行的代码，通常是写在诸如事件回调、Timer回调内的。这些回调会被runLoop创建好的AutoreleasePool环绕着。这就解释了，为什么即使程序中只有main函数的最外层设置autoreleasepool，所有的内存也不是在main运行完后一股脑一起释放的原因，可以说最外层的autoreleasepool只是为了保护所有没有被内建的autoreleasepool包裹住的部分内存自动回收用的。

通过下面的例子，我们来看一下，runLoop创建的autoreleasepool是不是真的帮我们管理了内存。

__weak id reference = nil;  
- (void)viewDidLoad {  
    [super viewDidLoad];  
    NSString *str = [NSString stringWithFormat:@"autoreleasePool"];  
    // str是一个autorelease对象，设置一个weak的引用来观察它  
    reference = str;  
    NSLog(@"%@", reference); // Console: autoreleasePool  
}  
- (void)viewWillAppear:(BOOL)animated {  
    [super viewWillAppear:animated];  
    NSLog(@"%@", reference); // Console: autoreleasePool  
}  
- (void)viewDidAppear:(BOOL)animated {  
    [super viewDidAppear:animated];  
    NSLog(@"%@", reference); // Console: (null)  
}

这个实验同时也证明了viewDidLoad和viewWillAppear是在同一个runloop调用的，而viewDidAppear是在之后的某个runloop调用的。由于这个vc在loadView之后便add到了window层级上，所以viewDidLoad和viewWillAppear是在同一个runloop调用的，因此在viewWillAppear中，这个autorelease的变量依然有值。
当然，我们也可以不用等到当前runLoop结束，选择手动干预Autorelease对象的释放时机：

- (void)viewDidLoad {  
    [super viewDidLoad];  
    @autoreleasepool {  
        NSString *str = [NSString stringWithFormat:@"autoreleasePool"];  
    }  
    NSLog(@"%@", str); // Console: (null)  
}

通过上面的例子，可以看出，没有调用release也做到了内存管理。可是大家注意到了，str对象没有调用autorelease方法啊，怎么被放到autoreleasepool进行管理的呢？其实静态方法已经在内部自动调用了autorelease方法，所有这里不需要再调用。
更进一步讲，ARC在进行内存释放管理的时候，如果某个对象是在独立作用域中创建并且使用，没有外层作用域对它的引用的话(没有外层作用域指针指向，也没有从函数返回值中返回)，则很可能编译的时候使用release立刻释放。但若不是这样，则一定使用autorelease来减少复杂度，比如上面的stringWithFormat静态方法，就是在其函数内执行了[NSString alloc]，但其创建对象的引用作为返回值进行了返回，所以必然会添加autorelease，因为如果是使用release的话，由于编译器必须在return函数前面来调用release函数，而调用release函数后引用计数==0立刻释放了该对象，则无论如何都会返回一个已经被释放的野指针作为函数返回值，唯一的办法就只能是把release延迟调用，来起码等到调用者拿到对象的引用并决定是weak还是strong之后再延迟释放。

=========================================
继续我们的主题。我们知道autoreleasepool是一个自动释放池，那么它到底是一个什么样的数据结构呢？我们在命令行中使用 clang -rewrite-objc main.m 让编译器重新改写这个文件，编译完后，会在该文件目录下多一个.cpp文件。打开这个文件。滚到最底部。可以看到如下代码：（删除掉多余的代码）
很遗憾的是这里只能看到autoreleasepool被编译的部分，如果还有NSObject *obj = [[NSObject alloc] init];这种定义，是看不到编译器自动在最后加上的[obj release]调用的，可能是这部分属于llvm的特性，用clang的重写是看不到的。

int main(int argc, const charchar * argv[]) {  
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;  
    }  
    return 0;  
}

在这个文件中，有一个非常奇怪的 __AtAutoreleasePool 的结构体，前面的注释写到/* @autoreleasepopl */ 。也就是说@autoreleasepool {} 被转换为：__AtAutoreleasePool __autoreleasepool。那么__AtAutoreleasePool又是什么？在文件中可以找到__AtAutoreleasePool数据结构如下：

struct __AtAutoreleasePool {  
  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}  
  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}  
  voidvoid * atautoreleasepoolobj;  
};

它是一个结构体，该结构体会在初始化时调用 objc_autoreleasePoolPush() 方法，会在析构时调用objc_autoreleasePoolPop 方法。所以我们可以进一步将main函数中的代码改写为如下：

int main(int argc, const charchar * argv[]) {    
    {  
        voidvoid * atautoreleasepoolobj = objc_autoreleasePoolPush();  
  
        // do whatever you want  
  
        objc_autoreleasePoolPop(atautoreleasepoolobj);  
    }  
    return 0;  
}

@autoreleasepool 只是帮助我们少写了这两行代码而已，让代码看起来更美观，然后要根据上述两个方法来分析自动释放池的实现。objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 的实现：

voidvoid *objc_autoreleasePoolPush(void) {    
    return AutoreleasePoolPage::push();  
}  
  
void objc_autoreleasePoolPop(voidvoid *ctxt) {    
    AutoreleasePoolPage::pop(ctxt);  
}

__AtAutoreleasePool的Push和Pop方法看上去方法看上去是对 AutoreleasePoolPage对应静态方法push和pop的封装。
那么AutoreleasePoolPage又是一个什么东东呢？，它的定义可以在NSObject.mm文件中看到，定义如下：

class AutoreleasePoolPage {    
    magic_t const magic;  
    idid *next;  
    pthread_t const thread;  
    AutoreleasePoolPage * const parent;  
    AutoreleasePoolPage *child;  
    uint32_t const depth;  
    uint32_t hiwat;  
};

=========================================

以上的过程说明了autoreleasepool可以由系统调用自动多次嵌套，而且只对调用了autorelease的对象起作用。
ARC是在编译阶段由LLVM自动加入reatin，release，autorelease等操作函数，那么对于栈作用域的函数内部变量来说，会在函数退出之前对局部变量引用的对象执行release操作，当retainCount==0的时候立刻执行回收内存操作。而@autoreleasepool可以让这个操作提前，例如：

- (void) doSomething {

__weak NSMutableArray *wcollection;
@autoreleasepool{

     NSMutableArray *collection = @[].mutableCopy;
     wcollection = collection;

     for (int i = 0; i < 10e6; ++i) {

        NSString *str = [NSString stringWithFormat:@"hi + %d", i];

        [collection addObject:str];

    }
    NSLog(@"%d",_objc_rootRetainCount(collection)); //打印1
    NSLog(@"finished!");
}
NSLog(@"%d",[wcollection valueForKey:@"retainCount"]); //打印0
     // 其他的代码
    NSLog(@"completed!");
}

以上的例子中，如果不使用局部的@autoreleasepool（但是还是要保留{}以减小collection的作用域），则collection引用的对象虽然在{}作用域的最后会被release，并且将其中add过的str对象都做release操作，但由于str在通过静态方法创建的时候进行了一次持有并且用autorelease释放，所以str还占用的内存要在autoreleasepool drain的时候才能释放。另外还能确定在超过函数作用域的对象多次引用(比如doSomething中return collection)，或者多线程并发引用同一个外部对象的情况下，想通过添加release第一时间释放的难度太大，所以ARC会选择使用autorelease，在更外层更好控制的地方使用autoreleasepool进行延迟释放。

而如果在collection使用的外部套上@autoreleasepool，则执行完成后会立刻释放str所占用的内存，也就是说会降低整个函数执行过程中，内存占用的峰值。另外大量的释放内存也会占用不少cpu时间，所以在打印完finished!以后，到//其他代码执行之前，会卡住一段时间，从执行监视器视图看，这段时间内程序占用的内存会持续下降。

for(int i=0;i<10e6;i++){
[[NSString alloc] initWithFormat:@"hi:%d",i];
__weak NSString *str = [[NSString alloc] initWithFormat:@"hi:%d",i];
NSLog(@"%@",str); // 打印nil
NSString *str2 = [[NSString alloc] initWithFormat:@"hi:%d",i];
NSLog(@"%@",str2);// 打印字符串
}

ARC的情况下，第一种写法编译器会立刻优化为[[[NSString alloc] initWithFormat:@"hi:%d",i] release]，所以虽然cpu在不断的执行和创建销毁对象，但内存不变化。
第二种写法用弱引用接收跟不接收一下不能增加引用计数，则同理。打印为nil
第三种写法有区别，可以打印出字符串，编译器会在{}作用域的最后一行加上[str2 release]，而不是alloc之后立刻回收。
可以想象为一个虚拟的强引用指针
NSString *temp = [alloc init];
第一种写法什么都不做
第二种写法_weak NSString *str = temp;
第三种写法NSString *str2 = temp;
[temp release];
// alloc之后的代码

MRC的情况下就比较悲剧了,__weak在MRC下不可用编译不通过，另外两种写法都会因为没有release让内存持续增长，尤其是第一种写法，想release都没有办法。

=========================================

__autoreleasing修饰符的作用

切换到ARC之后，每个指向OC对象的指针，都被赋上了所有权修饰符。一共有__strong、__weak、__unsafe_unretained和__autoreleasing这样四种所有权修饰符。

当一个对象被赋值给一个使用__autoreleasing修饰符修饰的指针时，相当于这个对象在MRC下被发送了autorelease消息，也就是说它被注册到了autorelease pool中。

全局变量和实例变量是无法用__autoreleasing来修饰的，不然编译器会报错。
而局部变量用__autoreleasing修饰后，其指向的对象，在当前autorelease pool结束之前不会被回收，即使其生命的作用域结束。也就是说__autoreleasing让编译器改变了默认的处理原则。

__weak NSObject *weakObj1;
__weak NSObject *weakObj2;

{
    __autoreleasing NSObject *obj1 = [[NSObject alloc] init];
    weakObj1 = obj1; //weakObj1指向的对象已被注册到autorelease pool

    __strong NSObject *obj2 = [[NSObject alloc] init];
    weakObj2 = obj2;//weakObj2指向的对象没有被注册到autorelease pool
}
//局部变量obj1和obj2的作用域结束，
//此时weakObj2指向的对象不再被强引用，因此被回收；
//而obj1指向的对象仍然在autorelease pool中

NSLog(@"%@", weakObj1);//输出，因为此刻weakObj1在autorelease pool中，不会因为obj1作用域的结束而被回收
NSLog(@"%@", weakObj2);//输出null

=========================================

方法名检查

@interface XSQObject : NSObject

+ (NSString *)newHelloWorldString;
+ (NSString *)allocHelloWorldString;
+ (NSString *)copyHelloWorldString;

+ (NSString *)helloWorldString;
+ (NSString *)initHelloWorldString;
+ (NSString *)shitHelloWorldString;

@end

@implementation XSQObject

+ (NSString *)newHelloWorldString {
    return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}
+ (NSString *)allocHelloWorldString {
    return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}
+ (NSString *)copyHelloWorldString {
    return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}

+ (NSString *)helloWorldString {
    return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}
+ (NSString *)initHelloWorldString {
    return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}
+ (NSString *)shitHelloWorldString {
    return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}

@end

int main(int argc, char * argv[]) {
    @autoreleasepool {
        
        __weak NSString *newHelloWorldString = [XSQObject newHelloWorldString];
        __weak NSString *allocHelloWorldString = [XSQObject allocHelloWorldString];
        __weak NSString *copyHelloWorldString = [XSQObject copyHelloWorldString];
        //上面三个都有warning:
        //Assigning retained object to weak variable; object will be released after assignment
        NSLog(@"%@", newHelloWorldString);//输出null
        NSLog(@"%@", allocHelloWorldString);//输出null
        NSLog(@"%@", copyHelloWorldString);//输出null
        
        __weak NSString *helloWorldString = [XSQObject helloWorldString];
        __weak NSString *initHelloWorldString = [XSQObject initHelloWorldString];
        __weak NSString *shitHelloWorldString = [XSQObject shitHelloWorldString];
        //上面三个没有warning
        
        NSLog(@"%@", helloWorldString);//输出HelloWorld
        NSLog(@"%@", initHelloWorldString);//输出HelloWorld
        NSLog(@"%@", shitHelloWorldString);//输出HelloWorld
        
    }
    return 0;
}

虽然[XSQObject helloWorldString]和[XSQObject newHelloWorldString]两个方法的实现完全一样，但是它们返回的对象被赋值给__weak指针后，前者仍然存在，而后者则被销毁了。如果再加入@autorelease块做点实验，可以发现helloWorldString指向的对象其实已被注册到autorelease pool中。

对比内存管理原则，这就像是在MRC下，不以alloc/new/copy/mutableCopy开头的方法，会对返回的对象发送autorelease消息一样。而事实上，在ARC下，编译器会检查方法名是否以alloc/new/copy/mutableCopy开头，如果不是，则自动将返回的对象注册到autorelease pool中。

在一些特殊的情况下，程序员也可以手动给某些方法加上其他标记，来覆盖被编译器隐式加上的标记。

需要注意的一点是，clang的ARC文档描述如下：

Methods in the alloc, copy, init, mutableCopy, and new families are implicitly marked attribute((ns_returns_retained)). This may be suppressed by explicitly marking the method attribute((ns_returns_not_retained)).

但其实还有一个更详细的默认规则限定，那就是init用作实例方法的开头，其他的用作静态方法的开头。这就是为什么上面的例子中用init开头的静态方法却没有警告和预期结果的原因。

=========================================

更详细的内容可以参考
http://blog.csdn.net/shxwork/article/details/51437003
http://blog.csdn.net/shxwork/article/details/51363306
http://www.jianshu.com/p/1b66c4d47cd7 （强烈推荐）
http://www.jianshu.com/p/32265cbb2a26（强烈推荐）
http://www.jianshu.com/p/ec2c854b2efd

自动引用计数和@autoreleasepool

你可能感兴趣的:(自动引用计数和@autoreleasepool)