MRC、ARC和autorelease的区别

中级：MRC、ARC和autorelease的区别

这是Objective C通过引用计数来管理内存的一种方式，MRC为手动引用计数，ARC为自动引用计数，autorelease则是添加到自动释放池中。

1、ARC和MRC的区别：ARC相对于MRC，不需要手动书写retain/release/autorelease，而是在编译期和运行期这两部分帮助开发者管理内存。

在编译器的时候，ARC调用C接口实现的retain/release/autorelease，在运行期的时候使用runtime配合来实现内存管理。

2、autorelease分为两种情况：手动干预释放时机、系统自动释放。

手动干预释放机制：指定autoreleasepool，就是所谓的作用域大括号结束释放；
系统自动释放：不手动指定autoreleasepool。
autorelease对象除了作用域后，会被添加到最近一次创建的自动释放池中，并会在当前的runloop迭代结束时释放。

ps:runloop从程序启动到加载完成是一个完整的运行循环，然后会停下来，等待用户交互，用户的每一次交互都会启动一次运行循环，这时候会创建自动释放池，来处理用户所有的点击事件、触摸事件，在一次完整的运行循环结束之前，会销毁自动释放池，达到销毁对象的母的。

高级：MRC、ARC和autorelease的区别

除了以上部分之外，还需要了解，runtime是如何来进行内存管理的。

1、retain的实现

-(id)retain {
   return ((id)selft)->rootRetain();
}
inline id objc_object:: rootRetain() {
   if (isTaggedPointer()) return (id)this;
   return sidetable_retain();
}

所以说，retain是调用了sidetable_retain方法，再看看sidetable_retain的实现：

id objc_object::sidetable_retain() {
    //获取table
    SideTable &table = SideTables()[this];
    //加锁
    table,lock();
    //获取引用计数
    size_t &refcntStorage = table.refcnts[this];
    if( !(refcntStorage & SIDE_TABLE_RC_PINNED) ) {
        //增加引用计数
        refcntStorage += SIDE_TABLE_RC_ONE;
    }
    //解锁
    table.unlock();
    return (id)this;
}

可以看出，retain通过Sidetable这个数据结构来存储引用计数，下面是Sidetable的实现：

tyedef objc::DenseMap,size_t,true> RefcountMap;
struct SideTable {
    spinlock_t slock;   //自旋锁
    RefcountMap refcnts;
    weak_table_t weak_table;
    //省略....
}

可以看到，Sidetable存储了一个自旋锁，一个引用计数map，这个引用计数的map以对象的地址作为key，引用计数作为value，到这里，引用计数的底层已经清楚了。

2、release的实现

SideTable& table = SideTables()[this];
    bool do_dealloc = false;
    table.lock();
    //找到对应地址的
    RefcountMap::iterator it = table.refcnts.find(this);
    if (it == table.refcnts.end()) { //找不到的话，执行dellloc
        do_dealloc = true;
        table.refcnts[this] = SIDE_TABLE_DEALLOCATING;
    } else if (it->second < SIDE_TABLE_DEALLOCATING) {//引用计数小于阈值，dealloc
        do_dealloc = true;
        it->second |= SIDE_TABLE_DEALLOCATING;
    } else if (! (it->second & SIDE_TABLE_RC_PINNED)) {
    //引用计数减去1
        it->second -= SIDE_TABLE_RC_ONE;
    }
    table.unlock();
    if (do_dealloc  &&  performDealloc) {
        //执行dealloc
        ((void(*)(objc_object *, SEL))objc_msgSend)(this, SEL_dealloc);
    }
    return do_dealloc;

release的到这里也比较清楚了：查找map，对引用计数减1，如果引用计数小于阈值，则调用SEL_dealloc

3、autorelease的实现

上边说道，autorelease方法的作用是把对象放到autorelease pool中，到pool drain的时候，回释放池中的对象。举个例子：

__weak NSObject *obj;
NSObject *temp = [[NSObject alloc] init];
obj = temp;
NSLog(@"%@",obj);   //输出为：非空

当放到autoreleasepool中：

__weak NSObject *obj;
@autoreleasepool{
    NSObject *temp = [[NSObject alloc] init];
    obj = temp;
}
NSLog(@"%@",obj);   //输出为：null

可以看到，放到自动释放池中的对象在超出作用域后会立即释放。事实上在iOS 程序启动之后，主线程会启动一个Runloop，这个Runloop在每一次循环是被自动释放池包裹的，在合适的时候对池子进行清空。

那么，autoreleasepool是是如何释放的呢？

//autorelease方法
- (id)autorelease {
    return ((id)self)->rootAutorelease();
}
//rootAutorelease 方法
inline id objc_object::rootAutorelease()
{
    if (isTaggedPointer()) return (id)this;
    //检查是否可以优化
    if (prepareOptimizedReturn(ReturnAtPlus1)) return (id)this;
    //放到auto release pool中。
    return rootAutorelease2();
}
// rootAutorelease2
id objc_object::rootAutorelease2()
{
    assert(!isTaggedPointer());
    return AutoreleasePoolPage::autorelease((id)this);
}

可以看到，把一个对象放到auto release pool中，是调用了AutoreleasePoolPage::autorelease这个方法。

我们继续查看对应的实现：

public: static inline id autorelease(id obj)
    {
        assert(obj);
        assert(!obj->isTaggedPointer());
        id *dest __unused = autoreleaseFast(obj);
        assert(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  *dest == obj);
        return obj;
    }
static inline id *autoreleaseFast(id obj)
    {
        AutoreleasePoolPage *page = hotPage();
        if (page && !page->full()) {
            return page->add(obj);
        } else if (page) {
            return autoreleaseFullPage(obj, page);
        } else {
            return autoreleaseNoPage(obj);
        }
    }
id *add(id obj)
    {
        assert(!full());
        unprotect();
        id *ret = next;  // faster than `return next-1` because of aliasing
        *next++ = obj;
        protect();
        return ret;
    }

到这里，autorelease方法的实现就比较清楚了，

autorelease方法会把对象存储到AutoreleasePoolPage的链表里。等到auto release pool被释放的时候，把链表内存储的对象删除。所以，AutoreleasePoolPage就是自动释放池的内部实现。