iOS夯实：ARC时代的内存管理

ゝ一世哀愁。 2023-10-17 08:24 36阅读 0赞

本文授权转载，作者：[@方秋枋][Link 1]

**什么是ARC**

Automatic Reference Counting (ARC) is a compiler feature that provides automatic memory management of Objective-C objects. Rather than having to think about retain and release operations \[^1\]

\[^1\]: [ Transitioning to ARC Release Notes][Transitioning to ARC Release Notes]

ARC提供是一个编译器的特性，帮助我们在编译的时候自动插入管理引用计数的代码。

最重要的是我们要认识到ARC的本质仍然是通过引用计数来管理内存。因此有时候如果我们操作不当,仍然会有内存泄露的危险。下面就总结一下ARC时代可能出现内存泄露的场景。

**内存泄露类型**

1. 循环引用

基于引用计数的内存管理机制无法绕过的一个问题便是循环引用（retain cycle）

(Python同样也采用了基于引用计数的内存管理,但是它采用了另外的机制来清除引用循环导致的内存泄露，而OC和Swift需要我们自己来处理这样的问题\[^2\])

*  对象之间的循环引用：使用弱引用避免
 *  block与对象之间的循环引用：

会导致Block与对象之间的循环引用的情况有：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>self.myBlock&nbsp;=&nbsp;^{&nbsp;self.someProperty&nbsp;=&nbsp;XXX;&nbsp;};</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

对于这种Block与Self直接循环引用的情况,编译器会给出提示。

但是对于有多个对象参与的情况,编译器便无能为力了,因此涉及到block内使用到self的情况,我们需要非常谨慎。（推荐涉及到self的情况,如果自己不是非常清楚对象引用关系,统一使用解决方案处理）

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>someObject.someBlock&nbsp;=&nbsp;^{&nbsp;self.someProperty&nbsp;=&nbsp;XXX;&nbsp;};&nbsp;</code> 
      <code>//还没有循环引用</code> 
     </div> 
     <div> 
      <code>self.someObjectWithBlock&nbsp;=&nbsp;someObject;&nbsp;</code> 
      <code>//&nbsp;导致循环引用,且编译器不会提醒</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

解决方案：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>__weak&nbsp;SomeObjectClass&nbsp;*weakSelf&nbsp;=&nbsp;self;</code> 
     </div> 
     <div> 
      <code>SomeBlockType&nbsp;someBlock&nbsp;=&nbsp;^{ </code> 
     </div> 
     <div> 
      <code>SomeObjectClass&nbsp;*strongSelf&nbsp;=&nbsp;weakSelf;</code> 
     </div> 
     <div> 
      <code>if</code>&nbsp; 
      <code>(strongSelf&nbsp;==&nbsp;nil)&nbsp;{ </code> 
     </div> 
     <div> 
      <code>//&nbsp;The&nbsp;original&nbsp;self&nbsp;doesn't&nbsp;exist&nbsp;anymore.</code> 
     </div> 
     <div> 
      <code>//&nbsp;Ignore,&nbsp;notify&nbsp;or&nbsp;otherwise&nbsp;handle&nbsp;this&nbsp;case.</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
     <div> 
      <code>[strongSelf&nbsp;someMethod];</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

我们还有一种更简便的方法来进行处理,实际原理与上面是一样的,但简化后的指令更易用。

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>@weakify(self)</code> 
     </div> 
     <div> 
      <code>[self.context&nbsp;performBlock:^{ </code> 
     </div> 
     <div> 
      <code>//&nbsp;Analog&nbsp;to&nbsp;strongSelf&nbsp;in&nbsp;previous&nbsp;code&nbsp;snippet.</code> 
     </div> 
     <div> 
      <code>@strongify(self)</code> 
     </div> 
     <div> 
      <code>//&nbsp;You&nbsp;can&nbsp;just&nbsp;reference&nbsp;self&nbsp;as&nbsp;you&nbsp;normally&nbsp;would.&nbsp;Hurray.</code> 
     </div> 
     <div> 
      <code>NSError&nbsp;*error;</code> 
     </div> 
     <div> 
      <code>[self.context&nbsp;save:&amp;error];</code> 
     </div> 
     <div> 
      <code>//&nbsp;Do&nbsp;something</code> 
     </div> 
     <div> 
      <code>}];</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

你可以在这里找到@weakify,@strongify工具：[MyTools\_iOS][MyTools_iOS]

\[^2\]: [ How does Python deal with retain cycles?][How does Python deal with retain cycles]

1. NSTimer

一般情况下在Action/Target模式里 target一般都是被weak引用,除了NSTimer。

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>+&nbsp;(NSTimer&nbsp;*)timerWithTimeInterval:(NSTimeInterval)seconds</code> 
     </div> 
     <div> 
      <code>target:(id)target</code> 
     </div> 
     <div> 
      <code>selector:(SEL)aSelector</code> 
     </div> 
     <div> 
      <code>userInfo:(id)userInfo</code> 
     </div> 
     <div> 
      <code>repeats:(BOOL)repeats</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

NSTimer Class Reference指出NSTimer会强引用target。

> target
> 
> The object to which to send the message specified by aSelector when the timer fires. The timer maintains a strong reference to this object until it (the timer) is invalidated.

然后官方的Timer Programming Topics指出： 我们不应该在dealloc中invalidate timer。

> A timer maintains a strong reference to its target. This means that as long as a timer remains valid, its target will not be deallocated. As a corollary, this means that it does not make sense for a timer’s target to try to invalidate the timer in its dealloc method—the dealloc method will not be invoked as long as the timer is valid.

举一个例子，我们让timer在我们的ViewController中不断调用handleTimer方法.

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>-&nbsp;(void)viewDidLoad</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code>[</code> 
      <code>super</code>&nbsp; 
      <code>viewDidload];</code> 
     </div> 
     <div> 
      <code>self.timer&nbsp;=&nbsp;[NSTimer&nbsp;scheduledTimerWithTimeInterval:1</code> 
     </div> 
     <div> 
      <code>target:self</code> 
     </div> 
     <div> 
      <code>selector:@selector(handleTimer:)</code> 
     </div> 
     <div> 
      <code>userInfo:nil</code> 
     </div> 
     <div> 
      <code>repeats:YES];</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

这个时候，timer和我们的ViewController就是循环引用的。即使我们在dealloc方法中invalidate timer也是没用的。因为timer强引用着VC。而dealloc是在对象销毁的时候才会被调用。

![循环引用.png][.png]

可能有人会有疑惑，如果VC不强引用timer。会发生什么呢？

NSTimer Class Reference指出: Runloop会强引用tiemr。这是理所当然的，因为如果一个timer是循环的，如果没被强引用，那么在函数返回后（比如上面的viewDidLoad函数），则会被销毁。自然就不能不断循环地通知持有的target。

> Note in particular that run loops maintain strong references to their timers, so you don’t have to maintain your own strong reference to a timer after you have added it to a run loop.

这个时候，Runloop, Timer和ViewController的关系是这样的。

![强引用.png][.png 1]

因为main runloop 的生命周期跟应用的生命周期是一致的，所以如果我们不主动invalidate timer,runloop就会一直持有timer,而timer也一直持有ViewController。同样也造成了内存泄露。

因此在使用NSTimer时，特别是循环的NSTimer时。我们需要注意在什么地方invalidate计时器，在上面这个例子，我们可以在viewWillDisappear里面做这样的工作。

**Swift's ARC**

在Swift中,ARC的机制与Objective-C基本是一致的。

相对应的解决方案：

*  对象之间的循环引用：使用弱引用避免

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>protocol&nbsp;aProtocol:class{}</code> 
     </div> 
     <div> 
      <code>class&nbsp;aClass{ </code> 
     </div> 
     <div> 
      <code>weak&nbsp;</code> 
      <code>var</code>&nbsp; 
      <code>delegate:aProtocol?</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

注意到这里,aProtocol通过在继承列表中添加关键词class来限制协议只能被class类型所遵循。这也是为什么我们能够声明delegate为weak的原因,weak仅适用于引用类型。而在Swift,enum与struct这些值类型中也是可以遵循协议的。

*  闭包引起的循环引用：

Swift提供了一个叫closure capture list的解决方案。

语法很简单,就是在闭包的前面用\[\]声明一个捕获列表。

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>let&nbsp;closure&nbsp;=&nbsp;{&nbsp;[weak&nbsp;self]&nbsp;</code> 
      <code>in</code> 
     </div> 
     <div> 
      <code>self?.doSomething()&nbsp;</code> 
      <code>//Remember,&nbsp;all&nbsp;weak&nbsp;variables&nbsp;are&nbsp;Optionals!</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

我们用一个实际的例子来介绍一下,比如我们常用的NotificationCenter：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>class&nbsp;aClass{ </code> 
     </div> 
     <div> 
      <code>var</code>&nbsp; 
      <code>name:String</code> 
     </div> 
     <div> 
      <code>init(name:String){ </code> 
     </div> 
     <div> 
      <code>self.name&nbsp;=&nbsp;name</code> 
     </div> 
     <div> 
      <code>NSNotificationCenter.defaultCenter().addObserverForName(</code> 
      <code>"print"</code> 
      <code>,&nbsp;object:&nbsp;self,&nbsp;queue:&nbsp;nil)</code> 
     </div> 
     <div> 
      <code>{&nbsp;[weak&nbsp;self]&nbsp;notification&nbsp;</code> 
      <code>in</code>&nbsp; 
      <code>print(</code> 
      <code>"hello&nbsp;\(self?.name)"</code> 
      <code>)}</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
     <div> 
      <code>deinit{ </code> 
     </div> 
     <div> 
      <code>NSNotificationCenter.defaultCenter().removeObserver(self)</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

**Swift的新东西**

swift为我们引入了一个新的关键词unowned。这个关键词同样用来管理内存和避免引用循环,和weak一样,unowned不会导致引用计数+1。

1. 那么几时用weak,几时用unowned呢？

举上面Notification的例子来说：

*  如果Self在闭包被调用的时候有可能是Nil。则使用weak
 *  如果Self在闭包被调用的时候永远不会是Nil。则使用unowned

2. 那么使用unowned有什么坏处呢？

如果我们没有确定好Self在闭包里调用的时候不会是Nil就使用了unowned。当闭包调用的时候,访问到声明为unowned的Self时。程序就会奔溃。这类似于访问了悬挂指针（进一步了解，请阅读[Crash in Cocoa][]）

对于熟悉Objective-C的大家来说,unowned在这里就类似于OC的unsafe\_unretained。在对象被清除后,声明为weak的对象会置为nil,而声明为unowned的对象则不会。

3. 那么既然unowned可能会导致崩溃,为什么我们不全部都用weak来声明呢？

原因是使用unowned声明,我们能直接访问。而用weak声明的,我们需要unwarp后才能使用。并且直接访问在速度上也更快。（[这位国外的猿说:Unowned is faster and allows for immutability and nonoptionality. If you don't need weak, don't use it.][Unowned is faster and allows for immutability and nonoptionality. If you don_t need weak_ don_t use it.]）

其实说到底,unowned的引入是因为Swift的Optional机制。

因此我们可以根据实际情况来选择使用weak还是unowned。个人建议,如果无法确定声明对象在闭包调用的时候永远不会是nil,还是使用weak来声明。安全更重要。

延伸阅读：[从Objective-C到Swift][Objective-C_Swift]

参考链接：

[shall-we-always-use-unowned-self-inside-closure-in-swif][]

[what-is-the-difference-between-a-weak-reference-and-an-unowned-reference][]

[Link 1]: http://weibo.com/p/1005051796648152/home?is_all=1
[Transitioning to ARC Release Notes]: https://developer.apple.com/library/mac/releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html
[MyTools_iOS]: https://github.com/100mango/MyTools_iOS
[How does Python deal with retain cycles]: http://www.quora.com/How-does-Python-deal-with-retain-cycles
[.png]: http://cc.cocimg.com/api/uploads/20160602/1464834456882778.png
[.png 1]: http://cc.cocimg.com/api/uploads/20160602/1464834492180894.png
[Crash in Cocoa]: https://github.com/100mango/zen/blob/master/iOS%E5%A4%AF%E5%AE%9E%EF%BC%9ACrash%20in%20Cocoa/Crash%20in%20Cocoa.md
[Unowned is faster and allows for immutability and nonoptionality. If you don_t need weak_ don_t use it.]: https://twitter.com/jckarter/status/667364165057515521
[Objective-C_Swift]: https://github.com/100mango/zen/blob/master/Swift%E5%AD%A6%E4%B9%A0%EF%BC%9A%E4%BB%8EObjective-C%E5%88%B0Swift/Swift%E5%AD%A6%E4%B9%A0%EF%BC%9A%E4%BB%8EObjective-C%E5%88%B0Swift.md
[shall-we-always-use-unowned-self-inside-closure-in-swif]: http://stackoverflow.com/questions/24320347/shall-we-always-use-unowned-self-inside-closure-in-swift
[what-is-the-difference-between-a-weak-reference-and-an-unowned-reference]: http://stackoverflow.com/questions/24011575/what-is-the-difference-between-a-weak-reference-and-an-unowned-reference