08--内存管理--一个对象什么时候加入自动释放池？

一个对象什么时候加入自动释放池？

误解一：ARC下的所有对象都会加入自动释放池？

自动释放池没有那么闲，苹果也没那么傻，一个没用的临时对象加到自动释放池有啥用？

误解二：@autoreleasepool {...}代码块中的自动释放池都会加入自动释放池？

原因同上

正解官方文档

image.png

避免一个对象被释放，例如从方法返回一个对象

可以通过几个例子来理解这段话

例子一：验证方法的返回

NSObject* testNoPoolWithReturn() {
    NSObject *obj = [NSObject new];
    return obj;
}

汇编调试，断点截图如下：

image.png

按照程序执行的流程来解读下这个现象

1. NSObject *obj = [NSObject new] 创建一个对象，引用计数为1；
2. return obj;，引用计数+1，并加入自动释放池；
3. 执行到}，给obj发送release消息，引用计数-1；

当执行完这个函数之后，这个对象的引用计数为1，这看起来是违背了retain/release成对执行的原则。事实上并没有，还有一次release消息发生在自动释放池pop的时候。程序这样设计的原因，可以保证从方法返回出去的对象一定是可以使用的，不会被释放掉，而且也不用担心这个对象的retain/release不一致的问题。当这个方法结束之后，外部拿到这个对象，是作为临时对象还是全局对象亦或是容器元素，那都不属于这个方法的管理范畴了，由外部自行管理其生命周期。

对比案例：很明显没有自动释放池相关的工作

void testNoPoolNoReturn() {
    NSObject *obj = [NSObject new];
    return;
}

image.png

例子二：验证类方法的返回

网上有大量的文章都误解了苹果文档中的for循环产生大量临时变量导致内存增加的原因，产生该现象必须满足三个条件：

1. for 循环
2. for 循环内存在类方法或使用外部函数的返回对象
3. 没有指定@autoreleasepool {...}

void testPoolNoReturn() {
    for (int i=0; i<10000; i++) {
//        @autoreleasepool {
//            NSObject *obj = [NSObject new];
//            NSLog(@"%@", obj);
//        }
        @autoreleasepool {
            NSString *str = [NSString stringWithFormat:@"%dadsfklasdfj;", 333];
            NSLog(@"%@", str);
        }
    }
}

先看看两段代码运行的结果：

image.png
image.png
从上面运行的结果，很明显可以看到，只有在NSString的类方法中才会有对象被加入自动释放池。类方法也属于方法的范畴，这个被加入自动释放池的对象是stringWithFormat方法内部的临时对象，而不是我们定义的变量str，而在new出一个对象的时候，是内部不存在临时变量的，所以就不会出现被加入到自动释放池的现象。

当我们把@autoreleasepool {...}代码块去掉，其运行结果为：

void testPoolNoReturn() {
    for (int i=0; i<10000; i++) {
//        @autoreleasepool {
//            NSObject *obj = [NSObject new];
//            NSLog(@"%@", obj);
//        }
//        @autoreleasepool {
            NSString *str = [NSString stringWithFormat:@"%dadsfklasdfj;", 333];
            NSLog(@"%@", str);
//        }
    }
}

image.png

仍然会加入自动释放池，只是这两个池子不一样

• 使用@autoreleasepool {...}时，加入的是这个新的自动释放池，当出这个代码块时，便会给池子里的对象发送release消息，因此可以避免内存的暴增；
• 不使用@autoreleasepool {...}时，加入的是最外层的那个自动释放池。而这个自动释放池需要等到下一个runloop周期才会给池子里的对象发送release消息，也就造成了内存的临时暴增显现；

objc_retainAutoreleaseReturnValue原理

从上面的调试过程中，可以知道，当一个对象加入自动释放池时，其实会调用objc_retainAutoreleaseReturnValue方法，其源码如下所示：

// Prepare a value at +0 for return through a +0 autoreleasing convention.
id 
objc_retainAutoreleaseReturnValue(id obj)
{
    if (prepareOptimizedReturn(ReturnAtPlus0)) return obj;

    // not objc_autoreleaseReturnValue(objc_retain(obj)) 
    // because we don't need another optimization attempt
    return objc_retainAutoreleaseAndReturn(obj);
}

这段代码在上一篇文章中已经做过分析了。
if (prepareOptimizedReturn(ReturnAtPlus0)) return obj;表示尝试将对象加入TLS中，如果成功加入，则没有自动释放池什么事了。大部分都会走到下面的流程：
objc_retainAutoreleaseAndReturn(obj);，其内部函数调用流程为：

objc_retainAutoreleaseAndReturn(obj)
----return objc_retainAutorelease(obj);
--------return objc_autorelease(objc_retain(obj));
------------return rootAutorelease();
----------------return rootAutorelease2();
--------------------return AutoreleasePoolPage::autorelease((id)this);
------------------------autoreleaseFast(obj);
----------------------------return page->add(obj);
--------------------------------*next++ = obj;

在对象被加入自动释放池之前，会先将对象retain一次，return objc_autorelease(objc_retain(obj));，然后将对象的地址存到自动释放池的双向链表的next数组中。

如果一个对象已经存在了自动释放池中，是否还会被加入自动释放池？

源码中，在objc_retainAutoreleaseAndReturn(obj)函数之后，还存在一个objc_retainAutoreleasedReturnValue方法，从函数命名可以猜出这个是对已经加入自动释放池的对象再次加入。而代码实现仅仅是将对象retain了一次，并没有自动释放池相关的代码，事实是这样的吗？

// Accept a value returned through a +0 autoreleasing convention for use at +1.
id
objc_retainAutoreleasedReturnValue(id obj)
{
    if (acceptOptimizedReturn() == ReturnAtPlus1) return obj;

    return objc_retain(obj);
}

测试代码：

NSObject* testNoPoolWithReturn() {
    printf("testNoPoolWithReturn enter\n");
    NSObject *obj = [NSObject new];
    printf("testNoPoolWithReturn return\n");
    return obj;
}

NSObject* testNoPoolWithReturn2() {
    printf("testNoPoolWithReturn2 enter\n");
    NSObject *obj = testNoPoolWithReturn();
    printf("testNoPoolWithReturn2 return\n");
    return obj;
}

objc_retainAutoreleaseReturnValue(id obj)
{
    if (prepareOptimizedReturn(ReturnAtPlus0)) return obj;

    printf("objc_retainAutoreleaseReturnValue 111111\n");
    // not objc_autoreleaseReturnValue(objc_retain(obj)) 
    // because we don't need another optimization attempt
    return objc_retainAutoreleaseAndReturn(obj);
}

objc_retainAutoreleasedReturnValue(id obj)
{
    if (acceptOptimizedReturn() == ReturnAtPlus1) return obj;

    printf("objc_retainAutoreleasedReturnValue 222222\n");
    return objc_retain(obj);
}

输出结果：

testNoPoolWithReturn2 enter
testNoPoolWithReturn enter
testNoPoolWithReturn return
objc_retainAutoreleaseReturnValue 111111
objc_retainAutoreleasedReturnValue 222222
testNoPoolWithReturn2 return
objc_retainAutoreleaseReturnValue 111111

得出结论：

1. 只要是方法return一个对象之前，都会调用objc_retainAutoreleaseReturnValue方法，将对象加入自动释放池；
2. 对于一个已经存在自动释放池的对象，会调用objc_retainAutoreleasedReturnValue方法，使其引用计数+1；

分析引用计数：

objc_autoreleasePoolPush

1. NSObject *obj = [NSObject new];：引用计数为1
2. return obj;：引用计数+1，加入自动释放池，为2
3. }：对obj发送release，引用计数为1
4. NSObject *obj = testNoPoolWithReturn();：objc_retainAutoreleasedReturnValue，引用计数+1，为2
5. return obj;：引用计数+1，加入自动释放池，为3
6. }：对obj发送release，引用计数为2

objc_autoreleasePoolPop：存了两遍，发两次release消息，引用计数为0