從上個(gè)月開(kāi)始接觸OC語(yǔ)言，ARC全稱Auto Reference Counting自動(dòng)引用計(jì)數(shù)，是OC的內(nèi)存管理機(jī)制。在C語(yǔ)言中，如果要在堆上分配一塊內(nèi)存：

// 分配內(nèi)存
char *str = (char *)malloc(10);

// 釋放內(nèi)存
free(str);

在面向過(guò)程的編程中，這種內(nèi)存管理方式十分有效，但在面向?qū)ο缶幊痰倪^(guò)程中，這種手動(dòng)的內(nèi)存分配與釋放會(huì)極大的增加代碼的復(fù)雜度。于是面向?qū)ο蟮恼Z(yǔ)言引入了各種各樣的內(nèi)存管理方法，比如Java的GC和OC的ARC。
ARC介于自動(dòng)垃圾回收和手動(dòng)內(nèi)存管理之間，ARC讓我們不再需要手動(dòng)書(shū)寫(xiě)retain/release/autorealease語(yǔ)句，但它不等同于垃圾回收，ARC無(wú)法處理retaincycles，在ARC中，如果兩個(gè)對(duì)象相互強(qiáng)引用會(huì)導(dǎo)致它們永遠(yuǎn)不會(huì)被釋放，即便沒(méi)有任何其他的對(duì)象引用它們。因此ARC能免去大部分的內(nèi)存管理問(wèn)題，但仍需要我們自己避免retaincycles或者手動(dòng)打斷對(duì)象之間的retain循環(huán)。
GC是Java運(yùn)行時(shí)的垃圾回收機(jī)制，而ARC是編譯時(shí)自動(dòng)插入對(duì)應(yīng)的代碼。
OC的引用計(jì)數(shù)理解非常簡(jiǎn)單，當(dāng)一個(gè)對(duì)象被持有的時(shí)候計(jì)數(shù)加一，不再被持有的時(shí)候引用計(jì)數(shù)減一，當(dāng)引用計(jì)數(shù)為零的時(shí)候，對(duì)象沒(méi)有被使用了，將其釋放，引用計(jì)數(shù)分為兩種：
1.手動(dòng)引用計(jì)數(shù)（MRC）
2.自動(dòng)引用計(jì)數(shù)（ARC）
在IOS早期開(kāi)發(fā)的時(shí)候，代碼都是采用MRC的，在Xcode的配置中，設(shè)置Build Settings中Object-C Automatic Reference Counting為no，或者配置CLANG_ENABLE_OBJC_ARC = NO，即可更換ARC為MRC，MRC代碼如下：

    @autoreleasepool {
        // 新建對(duì)象
        NSObject *obj = [[NSObject alloc] init];
        // 引用計(jì)數(shù)+1
        [obj retain];
        // 引用計(jì)數(shù)-1
        [obj release];
        // 將對(duì)象添加到自動(dòng)釋放池，在代碼段結(jié)束的時(shí)候會(huì)自動(dòng)調(diào)用release，引用計(jì)數(shù)-1
        [obj autorelease];
    }

MRC需要開(kāi)發(fā)者在內(nèi)存管理上花費(fèi)大量的時(shí)間，并且容易因?yàn)榫帉?xiě)遺漏導(dǎo)致內(nèi)存泄漏或操作野指針，僵尸對(duì)象導(dǎo)致crash。于是OC引入了ARC，編譯器自動(dòng)插入對(duì)應(yīng)代碼。ARC代碼如下：

    {
        NSObject *obj = [[NSObject alloc] init];
        // 在代碼塊執(zhí)行結(jié)束的時(shí)候會(huì)自動(dòng)調(diào)用[obj release]
    }

源碼分析

可見(jiàn)ARC的內(nèi)部實(shí)現(xiàn)依賴于MRC的三個(gè)內(nèi)存管理方法：
1.retain 增加引用計(jì)數(shù)
2.release 減少引用計(jì)數(shù)，當(dāng)引用計(jì)數(shù)降為0的時(shí)候，釋放對(duì)象
3.autorelease 與autoreleasepool結(jié)合使用，在自動(dòng)釋放池結(jié)束后，減少引用計(jì)數(shù)
這三個(gè)方法來(lái)自于NSObject協(xié)議，NSObject類本身實(shí)現(xiàn)了NSObject協(xié)議，所以查找NSObject源碼，從retain方法開(kāi)始：

// NSObject.mm
- (id)retain {
    return _objc_rootRetain(self);
}

NEVER_INLINE id
_objc_rootRetain(id obj)
{
    ASSERT(obj);

    return obj->rootRetain();
}

// objc-object.h
inline id 
objc_object::rootRetain()
{
    if (isTaggedPointer()) return (id)this;
    return sidetable_retain();
}

// NSObject.mm
id
objc_object::sidetable_retain()
{
#if SUPPORT_NONPOINTER_ISA
    ASSERT(!isa.nonpointer);
#endif
    // 獲取table
    SideTable& table = SideTables()[this];
    // 加鎖
    table.lock();
    // 獲取引用計(jì)數(shù)器
    size_t& refcntStorage = table.refcnts[this];
    if (! (refcntStorage & SIDE_TABLE_RC_PINNED)) {
        // 引用計(jì)數(shù)+1
        refcntStorage += SIDE_TABLE_RC_ONE;
    }
    // 解鎖
    table.unlock();

    return (id)this;
}

typedef objc::DenseMap<DisguisedPtr<objc_object>,size_t,RefcountMapValuePurgeable> RefcountMap;

// SideTable結(jié)構(gòu)體
struct SideTable {
    // 自旋鎖
    spinlock_t slock;
    RefcountMap refcnts;
    weak_table_t weak_table;

    SideTable() {
        memset(&weak_table, 0, sizeof(weak_table));
    }

    ~SideTable() {
        _objc_fatal("Do not delete SideTable.");
    }

    void lock() { slock.lock(); }
    void unlock() { slock.unlock(); }
    void forceReset() { slock.forceReset(); }

    // Address-ordered lock discipline for a pair of side tables.

    template<HaveOld, HaveNew>
    static void lockTwo(SideTable *lock1, SideTable *lock2);
    template<HaveOld, HaveNew>
    static void unlockTwo(SideTable *lock1, SideTable *lock2);
};

從上面可以看到，retain通過(guò)SideTable數(shù)據(jù)結(jié)構(gòu)來(lái)存儲(chǔ)引用計(jì)數(shù)，然后使用自旋鎖spinlock_t，和一個(gè)引用計(jì)數(shù)的RefcountMap，map以對(duì)象地址作為key，引用計(jì)數(shù)作為value。簡(jiǎn)而言之就是：
使用一個(gè)全局map，以對(duì)象地址為key，引用計(jì)數(shù)值為value。
再看看release的實(shí)現(xiàn)：

// NSObject.mm
- (oneway void)release {
    _objc_rootRelease(self);
}

NEVER_INLINE void
_objc_rootRelease(id obj)
{
    ASSERT(obj);

    obj->rootRelease();
}

// objc-object.h
inline bool 
objc_object::rootRelease()
{
    if (isTaggedPointer()) return false;
    return sidetable_release(true);
}

// NSObject.mm
uintptr_t
objc_object::sidetable_release(bool performDealloc)
{
#if SUPPORT_NONPOINTER_ISA
    ASSERT(!isa.nonpointer);
#endif
    // 獲取table
    SideTable& table = SideTables()[this];
    // dealloc標(biāo)志
    bool do_dealloc = false;
    // 加鎖
    table.lock();
    // try_emplace ：如果鍵不存在則插入，如果鍵存在則不做任何事
    // try_emplace ：獲取當(dāng)前對(duì)象的銷毀狀態(tài)，有兩個(gè)返回值，first是遍歷器，second返回值表示key value在map中是否已存在
    auto it = table.refcnts.try_emplace(this, SIDE_TABLE_DEALLOCATING);
    // 獲取引用計(jì)數(shù)
    auto &refcnt = it.first->second;
    // 如果對(duì)象之前不再map中
    if (it.second) {
        // 需要銷毀
        do_dealloc = true;
    } else if (refcnt < SIDE_TABLE_DEALLOCATING) {
        // 如果引用計(jì)數(shù)的值小于 SIDE_TABLE_DEALLOCATING = 2(0010)
        // refcnt 低兩位分別是
        // SIDE_TABLE_WEAKLY_REFERENCED：0
        // SIDE_TABLE_DEALLOCATING：1
        // 對(duì)象需要銷毀，并將標(biāo)志位置為SIDE_TABLE_DEALLOCATING
        do_dealloc = true;
        refcnt |= SIDE_TABLE_DEALLOCATING;
    } else if (! (refcnt & SIDE_TABLE_RC_PINNED)) {
        // 如果引用計(jì)數(shù)有值且未溢出，那么計(jì)數(shù)-1
        refcnt -= SIDE_TABLE_RC_ONE;
    }
    // 解鎖
    table.unlock();

    // 需要銷毀，則調(diào)用對(duì)象的dealloc方法
    if (do_dealloc  &&  performDealloc) {
        ((void(*)(objc_object *, SEL))objc_msgSend)(this, @selector(dealloc));
    }
    return do_dealloc;
}

從上面可以總結(jié)的出：release方法通過(guò)查找map，對(duì)引用計(jì)數(shù)減1，如果引用計(jì)數(shù)低于閾值，則調(diào)用dealloc方法。

Autorelease pool

上面提到autorelease pool在對(duì)象調(diào)用autorelease方法會(huì)將對(duì)象放到autorelease pool中，到自動(dòng)釋放池結(jié)束的時(shí)候，會(huì)釋放池中的對(duì)象。在ARC下，alloc/init/new/copy/mutableCopy方法都不是autorelease對(duì)象，舉個(gè)例子：

@interface ReleaseObject: NSObject
@end

@implementation ReleaseObject
//這個(gè)方法返回autorelease對(duì)象
+ (instancetype)object{
    return [[ReleaseObject alloc] init];
}

- (void)dealloc{
    NSLog(@"ReleaseObject Dealloc");
}
@end

首先確認(rèn)object返回的對(duì)象：

    __weak ReleaseObject * weakRef;
    @autoreleasepool {
        ReleaseObject * temp = [ReleaseObject object];
        weakRef = temp;
    }
    NSLog(@"%@",weakRef);

最終的輸出結(jié)果：

OCTest[26036:355949] ref : <ReleaseObject: 0x1005310b0>

可以看到直接使用alloc/init方法并不會(huì)返回autorelease對(duì)象，所以約定在構(gòu)造方法中加入autorelease方法，將object方法改為：

+(instancetype)object {
    return [[[ReleaseObject alloc] init] autorelease];
}

執(zhí)行結(jié)果：

OCTest[26645:363906] dealloc
OCTest[26645:363906] ref : (null)

從上面可以看到自動(dòng)釋放池的對(duì)象是在自動(dòng)釋放池作用域結(jié)束的時(shí)候立即釋放的。
OC提供了兩種方式來(lái)把對(duì)象添加到自動(dòng)釋放池：
1.NSAutoreleasePool（只能在MRC使用）
2.@autoreleasepool{} （代碼塊，ARC/MRC皆可使用）
查看autorelease方法源碼：

// NSObject.mm
- (id)autorelease {
    return _objc_rootAutorelease(self);
}

NEVER_INLINE id
_objc_rootAutorelease(id obj)
{
    ASSERT(obj);
    return obj->rootAutorelease();
}

// objc-object.h
inline id 
objc_object::rootAutorelease()
{
    if (isTaggedPointer()) return (id)this;
    if (prepareOptimizedReturn(ReturnAtPlus1)) return (id)this;

    return rootAutorelease2();
}

// NSObject.mm
__attribute__((noinline,used))
id 
objc_object::rootAutorelease2()
{
    ASSERT(!isTaggedPointer());
    return AutoreleasePoolPage::autorelease((id)this);
}

class AutoreleasePoolPage : private AutoreleasePoolPageData {
    ...
    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;
    }
    ...
}

從上面代碼看下來(lái)，稍稍有些疑惑，在autorelease中只是做了一個(gè)add的操作，換種思路分析一下，將以下代碼轉(zhuǎn)為匯編語(yǔ)言，查看其區(qū)別：

    // 代碼1:
    ReleaseObject *object = [[ReleaseObject alloc] init];
    [object release];
// 代碼1匯編
Ltmp0:
    .loc    1 12 29 prologue_end    ## OCTest/main.m:12:29
    movq    _OBJC_CLASSLIST_REFERENCES_$_(%rip), %rax
    movq    %rax, %rdi
    callq   _objc_alloc_init
    .loc    1 12 20 is_stmt 0       ## OCTest/main.m:12:20
    movq    %rax, -24(%rbp)
    .loc    1 13 6 is_stmt 1        ## OCTest/main.m:13:6
    movq    -24(%rbp), %rax
    .loc    1 13 5 is_stmt 0        ## OCTest/main.m:13:5
    movq    %rax, %rdi
    callq   *_objc_release@GOTPCREL(%rip)
    xorl    %eax, %eax
    .loc    1 14 5 is_stmt 1        ## OCTest/main.m:14:5
    addq    $32, %rsp
    popq    %rbp
    retq

    // 代碼2:
    @autoreleasepool {
        ReleaseObject *object = [[[ReleaseObject alloc] init] autorelease];
    }
// 代碼2匯編
Ltmp0:
    .loc    1 12 22 prologue_end    ## OCTest/main.m:12:22
    callq   _objc_autoreleasePoolPush
Ltmp1:
    .loc    1 13 34                 ## OCTest/main.m:13:34
    movq    _OBJC_CLASSLIST_REFERENCES_$_(%rip), %rcx
    movq    %rcx, %rdi
    movq    %rax, -32(%rbp)         ## 8-byte Spill
    callq   _objc_alloc_init
    .loc    1 13 33 is_stmt 0       ## OCTest/main.m:13:33
    movq    %rax, %rdi
    callq   _objc_autorelease
    .loc    1 13 24                 ## OCTest/main.m:13:24
    movq    %rax, -24(%rbp)
    movq    -32(%rbp), %rdi         ## 8-byte Reload
    .loc    1 14 5 is_stmt 1        ## OCTest/main.m:14:5
    callq   _objc_autoreleasePoolPop
    xorl    %eax, %eax
Ltmp2:
    .loc    1 15 5                  ## OCTest/main.m:15:5
    addq    $32, %rsp
    popq    %rbp
    retq

從上面的匯編代碼可以看到，在autoreleasepool的作用域上分別調(diào)用了_objc_autoreleasePoolPush，_objc_autoreleasePoolPop。接下來(lái)看這兩個(gè)函數(shù)分別做了什么：

// NSObject.mm
void *
_objc_autoreleasePoolPush(void)
{
    return objc_autoreleasePoolPush();
}

void *
objc_autoreleasePoolPush(void)
{
    return AutoreleasePoolPage::push();
}

class AutoreleasePoolPage : private AutoreleasePoolPageData {
    ...
    static inline void *push() 
    {
        id *dest;
        if (slowpath(DebugPoolAllocation)) {
            // Each autorelease pool starts on a new pool page.
            dest = autoreleaseNewPage(POOL_BOUNDARY);
        } else {
            dest = autoreleaseFast(POOL_BOUNDARY);
        }
        ASSERT(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
        return dest;
    }
    ...
}

在_objc_autoreleasePoolPush中可以看到熟悉的autoreleaseFast，但其中傳入的參數(shù)POOL_BOUNDARY的值為nil，解析autoreleaseFast方法流程：
1.獲取hotPage，hotPage上次添加obj的page
2.如果沒(méi)有hotPage，則表示pool還未創(chuàng)建，調(diào)用autoreleaseNoPage去創(chuàng)建一個(gè)page，并將obj壓入棧
3.如果hotPage沒(méi)有滿，則通過(guò)autoreleaseFullPage去遍歷page的子節(jié)點(diǎn)是否可以添加obj，如果不可以，則新建一個(gè)page并添加obj
4.對(duì)象添加到某個(gè)page之后，該page會(huì)作為hotPage
結(jié)合之前的add，可以明白page數(shù)據(jù)結(jié)構(gòu)的next指針向著添加到page的obj對(duì)象。
接下來(lái)看_objc_autoreleasePoolPop ：

// NSObject.mm
void
_objc_autoreleasePoolPop(void *ctxt)
{
    objc_autoreleasePoolPop(ctxt);
}

NEVER_INLINE
void
objc_autoreleasePoolPop(void *ctxt)
{
    AutoreleasePoolPage::pop(ctxt);
}

class AutoreleasePoolPage : private AutoreleasePoolPageData {
    ...
    static inline void
    pop(void *token)
    {
        AutoreleasePoolPage *page;
        id *stop;
        if (token == (void*)EMPTY_POOL_PLACEHOLDER) {
            // Popping the top-level placeholder pool.
            page = hotPage();
            if (!page) {
                // Pool was never used. Clear the placeholder.
                return setHotPage(nil);
            }
            // Pool was used. Pop its contents normally.
            // Pool pages remain allocated for re-use as usual.
            page = coldPage();
            token = page->begin();
        } else {
            page = pageForPointer(token);
        }

        stop = (id *)token;
        if (*stop != POOL_BOUNDARY) {
            if (stop == page->begin()  &&  !page->parent) {
                // Start of coldest page may correctly not be POOL_BOUNDARY:
                // 1. top-level pool is popped, leaving the cold page in place
                // 2. an object is autoreleased with no pool
            } else {
                // Error. For bincompat purposes this is not 
                // fatal in executables built with old SDKs.
                return badPop(token);
            }
        }

        if (slowpath(PrintPoolHiwat || DebugPoolAllocation || DebugMissingPools)) {
            return popPageDebug(token, page, stop);
        }

        return popPage<false>(token, page, stop);
    }
    ...
}

這里是根據(jù)傳入的token來(lái)確定pop的page：
1.token是EMPTY_POOL_PLACEHOLDER，表示pop最頂層
2.token為其他值，則調(diào)用pageForPointer計(jì)算page
3.確定page之后調(diào)用popPage<false>(token, page, stop)來(lái)釋放對(duì)象和清除page
查看pageForPointer方法：

    static AutoreleasePoolPage *pageForPointer(const void *p) 
    {
        return pageForPointer((uintptr_t)p);
    }

    static AutoreleasePoolPage *pageForPointer(uintptr_t p) 
    {
        AutoreleasePoolPage *result;
        uintptr_t offset = p % SIZE;

        ASSERT(offset >= sizeof(AutoreleasePoolPage));

        result = (AutoreleasePoolPage *)(p - offset);
        result->fastcheck();

        return result;
    }

最后查看popPage方法：

    template<bool allowDebug>
    static void
    popPage(void *token, AutoreleasePoolPage *page, id *stop)
    {
        if (allowDebug && PrintPoolHiwat) printHiwat();

        page->releaseUntil(stop);

        // memory: delete empty children
        // page為空
        if (allowDebug && DebugPoolAllocation  &&  page->empty()) {
            // special case: delete everything during page-per-pool debugging
            AutoreleasePoolPage *parent = page->parent;
            page->kill();
            setHotPage(parent);
        // page為空并且是根節(jié)點(diǎn)
        } else if (allowDebug && DebugMissingPools  &&  page->empty()  &&  !page->parent) {
            // special case: delete everything for pop(top)
            // when debugging missing autorelease pools
            page->kill();
            setHotPage(nil);
        // page有子節(jié)點(diǎn)
        } else if (page->child) {
            // hysteresis: keep one empty child if page is more than half full
            if (page->lessThanHalfFull()) {
                page->child->kill();
            }
            else if (page->child->child) {
                page->child->child->kill();
            }
        }
    }

    void releaseUntil(id *stop) 
    {
        // Not recursive: we don't want to blow out the stack 
        // if a thread accumulates a stupendous amount of garbage
        // 判斷是否釋放到了結(jié)束的對(duì)象
        while (this->next != stop) {
            // Restart from hotPage() every time, in case -release 
            // autoreleased more objects
            AutoreleasePoolPage *page = hotPage();

            // fixme I think this `while` can be `if`, but I can't prove it
            // page空了，就取父節(jié)點(diǎn)
            while (page->empty()) {
                page = page->parent;
                setHotPage(page);
            }

            page->unprotect();
            // 通過(guò)位置偏移從動(dòng)態(tài)數(shù)組中取出obj
            id obj = *--page->next;
            // 將這一塊內(nèi)存設(shè)置為SCRIBBLE
            memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
            page->protect();

            if (obj != POOL_BOUNDARY) {
                // 釋放對(duì)象
                objc_release(obj);
            }
        }

        setHotPage(this);

#if DEBUG
        // we expect any children to be completely empty
        for (AutoreleasePoolPage *page = child; page; page = page->child) {
            ASSERT(page->empty());
        }
#endif
    }

可以看到popPage方法調(diào)用page->releaseUntil(stop)來(lái)釋放page中的obj，releaseUntil從hotPage開(kāi)始遍歷對(duì)象執(zhí)行release操作，知道釋放到傳進(jìn)來(lái)的stop對(duì)象，當(dāng)某個(gè)page釋放完了，就找到它的parent來(lái)繼續(xù)遍歷釋放，并且修改hotPage為當(dāng)前遍歷的page。

至此autorelease pool的分析告一段落，總結(jié)為autorelease方法會(huì)將對(duì)象存儲(chǔ)到AutoreleasePoolPage的鏈表中去，等到調(diào)用_objc_autoreleasePoolPop方法的時(shí)候，將鏈表內(nèi)存儲(chǔ)的對(duì)象遍歷并且調(diào)用它們的_objc_autorelease方法。

參考文獻(xiàn)

深入理解ARC
retain和release實(shí)現(xiàn)探究
Autorelease的疑問(wèn)