使用__weak变量，指向的对象就会被加到autorelease

在《Objective-C高级编程》的第一部分内存管理中，有这么一节，其中说明了一个结论：

使用附有__weak修饰符的变量，即是使用注册到autoreleasepool中的对象。

按道理来说没有错。在ARC环境下，为了防止在使用过程中__weak指针指向的对象被释放，运行时系统就会自动将对象加入自动释放池中（ -autorelease ），延后释放过程。

1. 对于书中结论的验证

可是，按照书中的验证方式，我并没有发现autoreleasepool的容器中插入了对象。更离奇的是，书中还有说：

如果大量地使用附有__weak修饰符的变量，注册到autoreleasepool的对象也会大量增加。

{
    id __weak o = obj;
    NSLog(@"1 %@", o);
    NSLog(@"2 %@", o);
    NSLog(@"3 %@", o);
    NSLog(@"4 %@", o);
    NSLog(@"5 %@", o);
} 

通过调用 _objc_autoreleasePoolPrint() 函数，书中得到的结果是：

#########
AUTORELEASE POOLS for thread 0xad0392c0
6 releases pending
[0x6a85000] ............ PAGE (hot) (cold)
[0x6a85028] ############ POOL 0x6a85028
[0x6a8502c] 0x6719e40 NSObject
[0x6a85030] 0x6719e40 NSObject
[0x6a85034] 0x6719e40 NSObject
[0x6a85038] 0x6719e40 NSObject
[0x6a8503c] 0x6719e40 NSObject
########

可是实际上，我的到的结果是

objc[4106]: ##############
objc[4106]: AUTORELEASE POOLS for thread 0x1000a95c0
objc[4106]: 1 releases pending.
objc[4106]: [0x102801000] ................ PAGE (hot) (cold)
objc[4106]: [0x102801038] ############## POOL 0x102801038
objc[4106]: ##############

明显不一致。那么问题出在哪呢？

因为我想，使用__weak对象，即是对__weak对象发消息。因此，换一种方式，调用任意一个方法，比如：

@autoreleasepool {
    NSObject *obj = [[NSObject alloc] init];
    id __weak weakObj = obj;
    [weakObj description];
    [weakObj description];
    [weakObj description];
    [weakObj description];
    [weakObj description];
    _objc_autoreleasePoolPrint();
}

得到的结果是

objc[4279]: ##############
objc[4279]: AUTORELEASE POOLS for thread 0x1000a95c0
objc[4279]: 6 releases pending.
objc[4279]: [0x101003000] ................ PAGE (hot) (cold)
objc[4279]: [0x101003038] ################ POOL 0x101003038
objc[4279]: [0x101003040] 0x102025d00 __NSCFString
objc[4279]: [0x101003048] 0x1020022e0 __NSCFString
objc[4279]: [0x101003050] 0x102025cb0 __NSCFString
objc[4279]: [0x101003058] 0x102025db0 __NSCFString
objc[4279]: [0x101003060] 0x102025de0 __NSCFString
objc[4279]: ##############

这便与书中的结论不谋而合了。

同时，这也证实了“<u>使用附有__weak修饰符的变量，即是使用注册到autoreleasepool中的对象</u>”这一结论。

那么，添加到autoreleasepool的这一过程是如何实现的呢。

按书中所说，使用__weak对象之前，__weak指针进行了如下操作：

id tmp = objc_loadWeakRetained(&obj);
objc_autorelease(tmp);

其中，objc_loadWeakRetained实现如下：

id
objc_loadWeakRetained(id *location)
{
    // id *location即指向对象的指针（也就是weak指针的地址）
    
    id obj;
    id result;
    Class cls;

    SideTable *table;
    
 retry:
    obj = *location; // 取出对象
    if (!obj) return nil;
    if (obj->isTaggedPointer()) return obj;
    
    table = &SideTables()[obj]; // 获取对应的SideTable
    
    table->lock();
    if (*location != obj) {
        table->unlock();
        goto retry;
    }
    
    result = obj;

    cls = obj->ISA();
    if (! cls->hasCustomRR()) {
        assert(cls->isInitialized());
        
        // 没有覆盖内存管理的相关方法，
        // 则对obj进行retain操作
        if (! obj->rootTryRetain()) {
            // 不成功，返回nil
            result = nil;
        }
    }
    else {
        if (cls->isInitialized() || _thisThreadIsInitializingClass(cls)) {
            BOOL (*tryRetain)(id, SEL) = (BOOL(*)(id, SEL))
                class_getMethodImplementation(cls, SEL_retainWeakReference);
            if ((IMP)tryRetain == _objc_msgForward) {
                result = nil;
            }
            // tryRetain的IMP存在（函数指针存在）
            else if (! (*tryRetain)(obj, SEL_retainWeakReference)) {
                // 指行retain不成功，返回nil
                result = nil;
            }
        }
        else {
            // class没有初始化（首次访问）
            table->unlock();
            // 对cls进行初始化，之后重新检查
            _class_initialize(cls);
            goto retry;
        }
    }
        
    table->unlock();
    return result;
}

由代码可知，

1. 真正的操作即是对weak指向对象的 obj->rootTryRetain() 操作。在其中根据对象类型进行retain。
2. 之后，返回的tmp对象即为指向的对象（与obj相同），对其进行autorelease操作，将对象添加到底层当前的AutoReleasePoolPage中，以延后释放。
3. 最后，才可以正常使用__weak对象进行操作。
4. 当autoreleasepool准备drain时，才会将weak指向的对象进行release。

从此过程中，我们可以知道：

每使用一次__weak对象，运行时系统都会将其指向的原始对象先retain，之后保存到自动释放池中（ AutoReleasePoolPage的add() 函数）。因此如果大量调用__weak对象，则会重复进行此工作。不仅耗费无意义的性能（重复存储同一对象），还会使内存在短时间内大量增长。

2. NSLog引发的猜想

虽然过程明白了，但是还有一个问题，为什么按照书中，使用NSLog函数访问__weak对象，就不会将指向的对象加入到autoreleasepool中呢？

NSLog访问weak变量.jpg

如图，在调试代码过程中，偶然发现，在每次执行NSLog语句时，都会触发调用objc_autoreleasePoolPush函数，调用完成之后，还会执行objc_autoreleasePoolPop函数。这不就是明显的 @autoreleasepool{} 的实现吗？

通过调试不难发现，通过NSLog访问__weak对象并不是不触发添加到自动释放池的过程，而是在NSLog自身实现中，包含了自己的autoreleasepool，在调用过程中，__weak指向的对象被retain后，加入到了此内部的autoreleasepool中。待NSLog执行完成后，autoreleasepool在RunLoop的循环中被释放，其内部的对象也被移除出autoreleasepool后被执行release了。
因此，在外部方法执行过程中，__weak指针指向的对象的引用计数不发生变化，且所在的autoreleasepool中并不包含此对象就不难理解了。