從上個月開始接觸OC語言，ARC全稱Auto Reference Counting自動引用計數(shù)，是OC的內存管理機制。在C語言中，如果要在堆上分配一塊內存：
// 分配內存
char *str = (char *)malloc(10);
// 釋放內存
free(str);
在面向過程的編程中，這種內存管理方式十分有效，但在面向對象編程的過程中，這種手動的內存分配與釋放會極大的增加代碼的復雜度。于是面向對象的語言引入了各種各樣的內存管理方法，比如Java的GC和OC的ARC。
ARC介于自動垃圾回收和手動內存管理之間，ARC讓我們不再需要手動書寫retain/release/autorealease語句，但它不等同于垃圾回收，ARC無法處理retaincycles，在ARC中，如果兩個對象相互強引用會導致它們永遠不會被釋放，即便沒有任何其他的對象引用它們。因此ARC能免去大部分的內存管理問題，但仍需要我們自己避免retaincycles或者手動打斷對象之間的retain循環(huán)。
GC是Java運行時的垃圾回收機制，而ARC是編譯時自動插入對應的代碼。
OC的引用計數(shù)理解非常簡單，當一個對象被持有的時候計數(shù)加一，不再被持有的時候引用計數(shù)減一，當引用計數(shù)為零的時候，對象沒有被使用了，將其釋放，引用計數(shù)分為兩種：
1.手動引用計數(shù)（MRC）
2.自動引用計數(shù)（ARC）
在IOS早期開發(fā)的時候，代碼都是采用MRC的，在Xcode的配置中，設置Build Settings中Object-C Automatic Reference Counting為no，或者配置CLANG_ENABLE_OBJC_ARC = NO，即可更換ARC為MRC，MRC代碼如下：
@autoreleasepool {
// 新建對象
NSObject *obj = [[NSObject alloc] init];
// 引用計數(shù)+1
[obj retain];
// 引用計數(shù)-1
[obj release];
// 將對象添加到自動釋放池，在代碼段結束的時候會自動調用release，引用計數(shù)-1
[obj autorelease];
}
MRC需要開發(fā)者在內存管理上花費大量的時間，并且容易因為編寫遺漏導致內存泄漏或操作野指針，僵尸對象導致crash。于是OC引入了ARC，編譯器自動插入對應代碼。ARC代碼如下：
{
NSObject *obj = [[NSObject alloc] init];
// 在代碼塊執(zhí)行結束的時候會自動調用[obj release]
}
源碼分析
可見ARC的內部實現(xiàn)依賴于MRC的三個內存管理方法：
1.retain 增加引用計數(shù)
2.release 減少引用計數(shù)，當引用計數(shù)降為0的時候，釋放對象
3.autorelease 與autoreleasepool結合使用，在自動釋放池結束后，減少引用計數(shù)
這三個方法來自于NSObject協(xié)議，NSObject類本身實現(xiàn)了NSObject協(xié)議，所以查找NSObject源碼，從retain方法開始：
// 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();
// 獲取引用計數(shù)器
size_t& refcntStorage = table.refcnts[this];
if (! (refcntStorage & SIDE_TABLE_RC_PINNED)) {
// 引用計數(shù)+1
refcntStorage += SIDE_TABLE_RC_ONE;
}
// 解鎖
table.unlock();
return (id)this;
}
typedef objc::DenseMap<DisguisedPtr<objc_object>,size_t,RefcountMapValuePurgeable> RefcountMap;
// SideTable結構體
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通過SideTable數(shù)據(jù)結構來存儲引用計數(shù)，然后使用自旋鎖spinlock_t，和一個引用計數(shù)的RefcountMap，map以對象地址作為key，引用計數(shù)作為value。簡而言之就是：
使用一個全局map，以對象地址為key，引用計數(shù)值為value。
再看看release的實現(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標志
bool do_dealloc = false;
// 加鎖
table.lock();
// try_emplace ：如果鍵不存在則插入，如果鍵存在則不做任何事
// try_emplace ：獲取當前對象的銷毀狀態(tài)，有兩個返回值，first是遍歷器，second返回值表示key value在map中是否已存在
auto it = table.refcnts.try_emplace(this, SIDE_TABLE_DEALLOCATING);
// 獲取引用計數(shù)
auto &refcnt = it.first->second;
// 如果對象之前不再map中
if (it.second) {
// 需要銷毀
do_dealloc = true;
} else if (refcnt < SIDE_TABLE_DEALLOCATING) {
// 如果引用計數(shù)的值小于 SIDE_TABLE_DEALLOCATING = 2(0010)
// refcnt 低兩位分別是
// SIDE_TABLE_WEAKLY_REFERENCED：0
// SIDE_TABLE_DEALLOCATING：1
// 對象需要銷毀，并將標志位置為SIDE_TABLE_DEALLOCATING
do_dealloc = true;
refcnt |= SIDE_TABLE_DEALLOCATING;
} else if (! (refcnt & SIDE_TABLE_RC_PINNED)) {
// 如果引用計數(shù)有值且未溢出，那么計數(shù)-1
refcnt -= SIDE_TABLE_RC_ONE;
}
// 解鎖
table.unlock();
// 需要銷毀，則調用對象的dealloc方法
if (do_dealloc && performDealloc) {
((void(*)(objc_object *, SEL))objc_msgSend)(this, @selector(dealloc));
}
return do_dealloc;
}
從上面可以總結的出：release方法通過查找map，對引用計數(shù)減1，如果引用計數(shù)低于閾值，則調用dealloc方法。
Autorelease pool
上面提到autorelease pool在對象調用autorelease方法會將對象放到autorelease pool中，到自動釋放池結束的時候，會釋放池中的對象。在ARC下，alloc/init/new/copy/mutableCopy方法都不是autorelease對象，舉個例子：
@interface ReleaseObject: NSObject
@end
@implementation ReleaseObject
//這個方法返回autorelease對象
+ (instancetype)object{
return [[ReleaseObject alloc] init];
}
- (void)dealloc{
NSLog(@"ReleaseObject Dealloc");
}
@end
首先確認object返回的對象：
__weak ReleaseObject * weakRef;
@autoreleasepool {
ReleaseObject * temp = [ReleaseObject object];
weakRef = temp;
}
NSLog(@"%@",weakRef);
最終的輸出結果：
OCTest[26036:355949] ref : <ReleaseObject: 0x1005310b0>
可以看到直接使用alloc/init方法并不會返回autorelease對象，所以約定在構造方法中加入autorelease方法，將object方法改為：
+(instancetype)object {
return [[[ReleaseObject alloc] init] autorelease];
}
執(zhí)行結果：
OCTest[26645:363906] dealloc
OCTest[26645:363906] ref : (null)
從上面可以看到自動釋放池的對象是在自動釋放池作用域結束的時候立即釋放的。
OC提供了兩種方式來把對象添加到自動釋放池：
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;
}
...
}
從上面代碼看下來，稍稍有些疑惑，在autorelease中只是做了一個add的操作，換種思路分析一下，將以下代碼轉為匯編語言，查看其區(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的作用域上分別調用了_objc_autoreleasePoolPush，_objc_autoreleasePoolPop。接下來看這兩個函數(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.如果沒有hotPage，則表示pool還未創(chuàng)建，調用autoreleaseNoPage去創(chuàng)建一個page，并將obj壓入棧
3.如果hotPage沒有滿，則通過autoreleaseFullPage去遍歷page的子節(jié)點是否可以添加obj，如果不可以，則新建一個page并添加obj
4.對象添加到某個page之后，該page會作為hotPage
結合之前的add，可以明白page數(shù)據(jù)結構的next指針向著添加到page的obj對象。
接下來看_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來確定pop的page：
1.token是EMPTY_POOL_PLACEHOLDER，表示pop最頂層
2.token為其他值，則調用pageForPointer計算page
3.確定page之后調用popPage<false>(token, page, stop)來釋放對象和清除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é)點
} 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é)點
} 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
// 判斷是否釋放到了結束的對象
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é)點
while (page->empty()) {
page = page->parent;
setHotPage(page);
}
page->unprotect();
// 通過位置偏移從動態(tài)數(shù)組中取出obj
id obj = *--page->next;
// 將這一塊內存設置為SCRIBBLE
memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
page->protect();
if (obj != POOL_BOUNDARY) {
// 釋放對象
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方法調用page->releaseUntil(stop)來釋放page中的obj，releaseUntil從hotPage開始遍歷對象執(zhí)行release操作，知道釋放到傳進來的stop對象，當某個page釋放完了，就找到它的parent來繼續(xù)遍歷釋放，并且修改hotPage為當前遍歷的page。
至此autorelease pool的分析告一段落，總結為autorelease方法會將對象存儲到AutoreleasePoolPage的鏈表中去，等到調用_objc_autoreleasePoolPop方法的時候，將鏈表內存儲的對象遍歷并且調用它們的_objc_autorelease方法。
