iOS ARC全解?

2018-02-27 11:10:38来源:https://www.jianshu.com/p/516606198698作者:Silence_广人点击

分享


问题
简单介绍 ARC 以及 ARC 实现的原理。
考查点


我记得在刚接触iOS的时候对这个ARC和MRC就讨论颇深,认为ARC是对程序员的一种福利,让我们节省了大量的代码,那么ARC是什么呢?


ARC 是苹果在 WWDC 2011 提出来的技术,因此很多新入行的同学可能对此技术细节并不熟悉。但是,虽然 ARC 极大地简化了我们的内存管理工作,但是引用计数这种内存管理方案如果不被理解,那么就无法处理好那些棘手的循环引用问题。所以,这道面试题其实是考查同学对于 iOS 程序内存管理的理解深度。
答案


自动的引用计数(Automatic Reference Count 简称 ARC),是苹果在 WWDC 2011 年大会上提出的用于内存管理的技术。


引用计数(Reference Count)是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候,它的引用计数为 1,当有一个新的指针指向这个对象时,我们将其引用计数加 1,当某个指针不再指向这个对象是,我们将其引用计数减 1,当对象的引用计数变为 0 时,说明这个对象不再被任何指针指向了,这个时候我们就可以将对象销毁,回收内存。由于引用计数简单有效,除了 Objective-C 语言外,微软的 COM(Component Object Model )、C++11(C++11 提供了基于引用计数的智能指针 share_prt) 等语言也提供了基于引用计数的内存管理方式。


引用计数这种内存管理方式虽然简单,但是手工写大量的操作引用计数的代码不但繁琐,而且容易被遗漏。于是苹果在 2011 年引入了 ARC。ARC 顾名思义,是自动帮我们填写引用计数代码的一项功能。


ARC 的想法来源于苹果在早期设计 Xcode 的 Analyzer 的时候,发现编译器在编译时可以帮助大家发现很多内存管理中的问题。后来苹果就想,能不能干脆编译器在编译的时候,把内存管理的代码都自动补上,带着这种想法,苹果修改了一些内存管理代码的书写方式(例如引入了 @autoreleasepool 关键字)后,在 Xcode 中实现了这个想法。


ARC 的工作原理大致是这样:当我们编译源码的时候,编译器会分析源码中每个对象的生命周期,然后基于这些对象的生命周期,来添加相应的引用计数操作代码。所以,ARC 是工作在编译期的一种技术方案,这样的好处是:


编译之后,ARC 与非 ARC 代码是没有什么差别的,所以二者可以在源码中共存。实际上,你可以通过编译参数 -fno-objc-arc 来关闭部分源代码的 ARC 特性。


相对于垃圾回收这类内存管理方案,ARC 不会带来运行时的额外开销,所以对于应用的运行效率不会有影响。相反,由于 ARC 能够深度分析每一个对象的生命周期,它能够做到比人工管理引用计数更加高效。例如在一个函数中,对一个对象刚开始有一个引用计数 +1 的操作,之后又紧接着有一个 -1 的操作,那么编译器就可以把这两个操作都优化掉。


但是也有人认为,ARC 也附带有运行期的一些机制来使 ARC 能够更好的工作,他们主要是指 weak 关键字。weak 变量能够在引用计数为 0 时被自动设置成 nil,显然是有运行时逻辑在工作的。我通常并没有把这个算在 ARC 的概念当中,当然,这更多是一个概念或定义上的分歧,因为除开 weak 逻辑之外,ARC 核心的代码都是在编译期填充的。


作者:优雅地小男子


高级解析


前言


本文的ARC特指Objective C的ARC,并不会讲解其他语言。另外,本文涉及到的原理部分较多,适合有一定经验的开发者。


什么是ARC?


ARC的全称Auto Reference Counting. 也就是自动引用计数。那么,为什么要有ARC呢?


我们从C语言开始。使用C语言编程的时候,如果要在堆上分配一块内存,代码如下


`//分配内存(malloc/calloc均可)`
`int * array = calloc(10, sizeof (int));`
`//释放内存`
`free(array);1234512345`

C是面向过程的语言(Procedural programming),这种内存的管理方式简单直接。但是,对于面向对象编程,这种手动的分配释放毫无疑问会大大的增加代码的复杂度。


于是,OOP的语言引入了各种各样的内存管理方法,比如Java的垃圾回收和Objective C的引用计数。关于垃圾回收和饮用计数的对比,可以参见Brad Larson的这个SO回答。


Objective C的引用计数理解起来很容易,当一个对象被持有的时候计数加一,不再被持有的时候引用计数减一,当引用计数为零的时候,说明这个对象已经无用了,则将其释放。


引用计数分为两种:


手动引用计数(MRC)


自动引用计数(ARC)


在iOS开发早期,编写代码是采用MRC的



`// MRC代码`
`NSObject * obj = [[NSObject alloc] init]; ``//引用计数为1`
`//不需要的时候`
`[obj release] ``//引用计数减1`
`//持有这个对象`
`[obj retain] ``//引用计数加1`
`//放到AutoReleasePool`
`[obj autorelease]``//在auto release pool释放的时候,引用计数减1`


虽说这种方式提供了面向对象的内存管理接口,但是开发者不得不花大量的时间在内存管理上,并且容易出现内存泄漏或者release一个已被释放的对象,导致crash。


再后来,Apple对iOS/Mac OS开发引入了ARC。使用ARC,开发者不再需要手动的retain/release/autorelease. 编译器会自动插入对应的代码,再结合Objective C的runtime,实现自动引用计数。


比如如下ARC代码:



`NSObject * obj;`
`{`
`obj = [[NSObject alloc] init]; ``//引用计数为1`
`}`
`NSLog(@``"%@"``,obj);`


等同于如下MRC代码


`NSObject * obj;`
`{`
`obj = [[NSObject alloc] init]; ``//引用计数为1`
`[obj relrease]`
`}`
`NSLog(@``"%@"``,obj);`

在Objective C中,有三种类型是ARC适用的:


block


objective 对象,id, Class, NSError*等


由attribute((NSObject))标记的类型。


像double *,CFStringRef等不是ARC适用的,仍然需要手动管理内存。


Tips: 以CF开头的(Core Foundation)的对象往往需要手动管理内存。


属性所有权


最后,我们在看看ARC中常见的所有权关键字,


assign对应关键字__unsafe_unretained, 顾名思义,就是指向的对象被释放的时候,仍然指向之前的地址,容易引起野指针。


copy对应关键字__strong,只不过在赋值的时候,调用copy方法。


retain对应__strong


strong对应__strong


unsafe_unretained对应__unsafe_unretained


weak对应__weak。


其中,__weak和__strong是本文要讲解的核心内容。


ARC的内部实现


ARC背后的引用计数主要依赖于这三个方法:


retain 增加引用计数


release 降低引用计数,引用计数为0的时候,释放对象。


autorelease 在当前的auto release pool结束后,降低引用计数。


在Cocoa Touch中,NSObject协议中定义了这三个方法,由于Cocoa Touch中,绝大部分类都继承自NSObject(NSObject类本身实现了NSObject协议),所以可以“免费”获得NSObject提供的运行时和ARC管理方法,这就是为什么适用OC开发iOS的时候,你的类要继承自NSObject。


既然ARC是引用计数,那么对应一个对象,内存中必然会有一个地方来存储这个对象的引用计数。iOS的Runtime是开源的,在这里可以下载到全部的代码,我们通过源代码一探究竟。


我们从retain入手,



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


所以说,本质上retain就是调用sidetable_retain,再看看sitetable_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这个数据结构来存储引用计数。我们看看这个数据结构的实现:




QQ截图20170421165138.png

可以看到,这个数据结构就是存储了一个自旋锁,一个引用计数map。这个引用计数的map以对象的地址作为key,引用计数作为value。到这里,引用计数的底层实现我们就很清楚了。


存在全局的map,这个map以地址作为key,引用计数的值作为value。


再来看看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


Autorelease pool


上文提到了,autorelease方法的作用是把对象放到autorelease pool中,到pool drain的时候,会释放池中的对象。举个例子


`__weak NSObject * obj;`
`NSObject * temp = [[NSObject alloc] init];`
`obj = temp;`
`NSLog(@``"%@"``,obj); ``//非空`
|
放到auto release pool中,

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


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


对于Cocoa框架来说,提供了两种方式来把对象显式的放入AutoReleasePool.


NSAutoreleasePool(只能在MRC下使用)


@autoreleasepool {}代码块(ARC和MRC下均可以使用)


那么AutoRelease pool又是如何实现的呢?


我们先从autorelease方法源码入手


`//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就是自动释放池的内部实现。


__weak与__strong


用过block的同学一定写过类似的代码:



`__weak typeSelf(self) weakSelf = self;`
`[object fetchSomeFromRemote:^{`
`__strong typeSelf(weakSelf) strongSelf = weakSelf;`
`//从这里开始用strongSelf`
`}];`


那么,为什么要这么用呢?原因是:


block会捕获外部变量,用weakSelf保证self不会被block被捕获,防止引起循环引用或者不必要的额外生命周期。


用strongSelf则保证在block的执行过程中,对象不会被释放掉。


首先__strong和__weak都是关键字,是给编译器理解的。为了理解其原理,我们需要查看它们编译后的代码,使用XCode,我们可以容易的获得一个文件的汇编代码。


比如,对于Test.m文件,当源代码如下时:


`#import "Test.h"`
`@implementation Test`
`- (void)testFunction{`
`{`
`__strong NSObject * temp = [[NSObject alloc] init];`
`}`
`}`
`@end`


转换后的汇编代码如下:


`Ltmp3:`
`.loc 2 15 37 prologue_end ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:37`
`ldr x9, [x9]`
`ldr x1, [x8]`
`mov x0, x9`
`bl _objc_msgSend`
`adrp x8, L_OBJC_SELECTOR_REFERENCES_.2@PAGE`
`add x8, x8, L_OBJC_SELECTOR_REFERENCES_.2@PAGEOFF`
`.loc 2 15 36 is_stmt 0 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:36`
`ldr x1, [x8]`
`.loc 2 15 36 discriminator 1 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:36`
`bl _objc_msgSend`
`mov x8, ``#0`
`add x9, sp, ``#8 ; =8`
`.loc 2 15 29 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:29`
`str x0, [sp, ``#8]`
`Ltmp4:`
`.loc 2 16 5 is_stmt 1 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:16:5`
`mov x0, x9`
`mov x1, x8`
`bl _objc_storeStrong`
`.loc 2 17 1 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:17:1`
`ldp x29, x30, [sp, ``#32] ; 8-byte Folded Reload`
`add sp, sp, ``#48 ; =48`
`ret`
`Ltmp5:`


即使你不懂汇编,也能很轻易的获取到调用顺序如下



`_objc_msgSend ``// alloc`
`_objc_msgSend ``// init`
`_objc_storeStrong ``// 强引用`


在结合Runtime的源码,我们看看最关键的objc_storeStrong的实现


`void objc_storeStrong(id *location, id obj)`
`{`
`id prev = *location;`
`if` `(obj == prev) {`
`return``;`
`}`
`objc_retain(obj);`
`*location = obj;`
`objc_release(prev);`
`}`
`id objc_retain(id obj) { ``return` `[obj retain]; }`
`void objc_release(id obj) { [obj release]; }`


我们再来看看__weak. 将Test.m修改成为如下代码,同样我们分析其汇编实现


`.loc    2 15 35 prologue_end    ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:35`
`ldr x9, [x9]`
`ldr x1, [x8]`
`mov x0, x9`
`bl _objc_msgSend`
`adrp x8, L_OBJC_SELECTOR_REFERENCES_.2@PAGE`
`add x8, x8, L_OBJC_SELECTOR_REFERENCES_.2@PAGEOFF`
`.loc 2 15 34 is_stmt 0 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:34`
`ldr x1, [x8]`
`.loc 2 15 34 discriminator 1 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:34`
`bl _objc_msgSend`
`add x8, sp, ``#24 ; =24`
`.loc 2 15 27 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:27`
`mov x1, x0`
`.loc 2 15 27 discriminator 2 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:27`
`str x0, [sp, ``#16] ; 8-byte Folded Spill`
`mov x0, x8`
`bl _objc_initWeak`
`.loc 2 15 27 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:27`
`ldr x1, [sp, ``#16] ; 8-byte Folded Reload`
`.loc 2 15 27 discriminator 3 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:15:27`
`str x0, [sp, ``#8] ; 8-byte Folded Spill`
`mov x0, x1`
`bl _objc_release`
`add x8, sp, ``#24 `
`Ltmp4:`
`.loc 2 16 5 is_stmt 1 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:16:5`
`mov x0, x8`
`bl _objc_destroyWeak`
`.loc 2 17 1 ; /Users/hl/Desktop/OCTest/OCTest/Test.m:17:1`
`ldp x29, x30, [sp, ``#48] ; 8-byte Folded Reload`
`add sp, sp, ``#64 ; =64`
`ret`


可以看到,__weak本身实现的核心就是以下两个方法


_objc_initWeak


_objc_destroyWeak


我们通过Runtime的源码分析这两个方法的实现:


<false></false>



`id objc_initWeak(id *location, id newObj)`
`{`
`//省略....`
`return` `storeWeak (location, (objc_object*)newObj);`
`}`
`void objc_destroyWeak(id *location)`
`{`
`(void)storeWeak (location, nil);`
`}`


所以,本质上都是调用了storeWeak函数,这个函数内容较多,主要做了以下事情


获取存储weak对象的map,这个map的key是对象的地址,value是weak引用的地址。


当对象被释放的时候,根据对象的地址可以找到对应的weak引用的地址,将其置为nil即可。


这就是在weak背后的黑魔法。


总结


这篇文章属于想到哪里写到哪里的类型,后边有时间了在继续总结ARC的东西吧。








最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台