从上个月开始接触OC语言，ARC全称Auto Reference Counting自动引用计数，是OC的内存管理机制。在C语言中，如果要在堆上分配一块内存：
// 分配内存
char *str = (char *)malloc(10);
// 释放内存
free(str);
在面向过程的编程中，这种内存管理方式十分有效，但在面向对象编程的过程中，这种手动的内存分配与释放会极大的增加代码的复杂度。于是面向对象的语言引入了各种各样的内存管理方法，比如Java的GC和OC的ARC。
ARC介于自动垃圾回收和手动内存管理之间，ARC让我们不再需要手动书写retain/release/autorealease语句，但它不等同于垃圾回收，ARC无法处理retaincycles，在ARC中，如果两个对象相互强引用会导致它们永远不会被释放，即便没有任何其他的对象引用它们。因此ARC能免去大部分的内存管理问题，但仍需要我们自己避免retaincycles或者手动打断对象之间的retain循环。
GC是Java运行时的垃圾回收机制，而ARC是编译时自动插入对应的代码。
OC的引用计数理解非常简单，当一个对象被持有的时候计数加一，不再被持有的时候引用计数减一，当引用计数为零的时候，对象没有被使用了，将其释放，引用计数分为两种：
1.手动引用计数（MRC）
2.自动引用计数（ARC）
在IOS早期开发的时候，代码都是采用MRC的，在Xcode的配置中，设置Build Settings中Object-C Automatic Reference Counting为no，或者配置CLANG_ENABLE_OBJC_ARC = NO，即可更换ARC为MRC，MRC代码如下：
@autoreleasepool {
// 新建对象
NSObject *obj = [[NSObject alloc] init];
// 引用计数+1
[obj retain];
// 引用计数-1
[obj release];
// 将对象添加到自动释放池，在代码段结束的时候会自动调用release，引用计数-1
[obj autorelease];
}
MRC需要开发者在内存管理上花费大量的时间，并且容易因为编写遗漏导致内存泄漏或操作野指针，僵尸对象导致crash。于是OC引入了ARC，编译器自动插入对应代码。ARC代码如下：
{
NSObject *obj = [[NSObject alloc] init];
// 在代码块执行结束的时候会自动调用[obj release]
}
源码分析
可见ARC的内部实现依赖于MRC的三个内存管理方法：
1.retain 增加引用计数
2.release 减少引用计数，当引用计数降为0的时候，释放对象
3.autorelease 与autoreleasepool结合使用，在自动释放池结束后，减少引用计数
这三个方法来自于NSObject协议，NSObject类本身实现了NSObject协议，所以查找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();
// 获取引用计数器
size_t& refcntStorage = table.refcnts[this];
if (! (refcntStorage & SIDE_TABLE_RC_PINNED)) {
// 引用计数+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数据结构来存储引用计数，然后使用自旋锁spinlock_t，和一个引用计数的RefcountMap，map以对象地址作为key，引用计数作为value。简而言之就是：
使用一个全局map，以对象地址为key，引用计数值为value。
再看看release的实现：
// 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 ：获取当前对象的销毁状态，有两个返回值，first是遍历器，second返回值表示key value在map中是否已存在
auto it = table.refcnts.try_emplace(this, SIDE_TABLE_DEALLOCATING);
// 获取引用计数
auto &refcnt = it.first->second;
// 如果对象之前不再map中
if (it.second) {
// 需要销毁
do_dealloc = true;
} else if (refcnt < SIDE_TABLE_DEALLOCATING) {
// 如果引用计数的值小于 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)) {
// 如果引用计数有值且未溢出，那么计数-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，对引用计数减1，如果引用计数低于阈值，则调用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];
}
执行结果：
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的操作，换种思路分析一下，将以下代码转为汇编语言，查看其区别：
// 代码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。接下来看这两个函数分别做了什么：
// 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，但其中传入的参数POOL_BOUNDARY的值为nil，解析autoreleaseFast方法流程：
1.获取hotPage，hotPage上次添加obj的page
2.如果没有hotPage，则表示pool还未创建，调用autoreleaseNoPage去创建一个page，并将obj压入栈
3.如果hotPage没有满，则通过autoreleaseFullPage去遍历page的子节点是否可以添加obj，如果不可以，则新建一个page并添加obj
4.对象添加到某个page之后，该page会作为hotPage
结合之前的add，可以明白page数据结构的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);
}
...
}
这里是根据传入的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为空并且是根节点
} 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有子节点
} 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空了，就取父节点
while (page->empty()) {
page = page->parent;
setHotPage(page);
}
page->unprotect();
// 通过位置偏移从动态数组中取出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开始遍历对象执行release操作，知道释放到传进来的stop对象，当某个page释放完了，就找到它的parent来继续遍历释放，并且修改hotPage为当前遍历的page。
至此autorelease pool的分析告一段落，总结为autorelease方法会将对象存储到AutoreleasePoolPage的链表中去，等到调用_objc_autoreleasePoolPop方法的时候，将链表内存储的对象遍历并且调用它们的_objc_autorelease方法。
