Swift学习笔记 (三十六) 自动引用计数(上)

Java的垃圾回收：https://mp.weixin.qq.com/s/feJKRqYJTVEIxl6jvjevAg 墙裂推荐阿里出品

Swift 使用自动引用计数(ARC)机制来跟踪和管理你的应用程序的内存。通常情况下，Swift 内存管理机制会一直起作用，你无须

⾃己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。

然⽽在少数情况下，为了能帮助你管理内存，ARC 需要更多的，代码之间关系的信息。本章描述了这些情况，并且为你示范怎样

才能使 ARC 来管理你的应用程序的所有内存。在 Swift 使用 ARC 与在 Obejctive-C 中使用 ARC 非常类似，具体请参考《过渡

到 ARC 的发布说明》。

注意

引⽤计数仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。

 

⾃动引用计数的工作机制

当你每次创建一个类的新的实例的时候，ARC 会分配一块内存来储存该实例信息。内存中会包含实例的类型信息，以及这个实例

所有相关的存储型属性的值。

此外，当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直

占⽤内存空间。

然而，当 ARC 收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个

实例，你的应用程序很可能会崩溃。

为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引⽤数为

1，ARC 都不会销毁这个实例。

为了使上述成为可能，无论你将实例赋值给属性、常量或变量，它们都会创建此实例的强引用。之所以称之为“强”引用， 是因为

它会将实例牢牢地保持住，只要强引用还在，实例是不允许被销毁的。

 

⾃动引用计数实践

下⾯的例子展示了自动引用计数的工作机制。例子以一个简单的 Person 类开始，并定义了一个叫 name 的常量属性:

class Person {

    let name: String

    init(name: String) {

        self.name = name

        print("\(name) is being initialized")

    }

    deinit {

        print("\(name) is being deinitialized")

    }

}

Person 类有一个构造器，此构造器为实例的 name 属性赋值，并打印一条消息以表明初始化过程生效。 Person 类也拥有一个析

构器，这个析构器会在实例被销毁时打印一条消息。

接下来的代码片段定义了三个类型为 Person? 的变量，⽤来按照代码片段中的顺序，为新的 Person 实例建立多个引用。由于这

些变量是被定义为可选类型( Person? ，而不是 Person )，它们的值会被自动初始化为 nil ，⽬前还不会引用到 Person 类的实

例。

var reference1: Person?

var reference2: Person?

var reference3: Person?

现在你可以创建 Person 类的新实例，并且将它赋值给三个变量中的一个:

reference1 = Person(name: "John Appleseed")

// 打印“John Appleseed is being initialized”

应当注意到当你调用 Person 类的构造器的时候， "John Appleseed is being initialized" 会被打印出来。由此可以确定构造器被执

行。

由于 Person 类的新实例被赋值给了 reference1 变量，所以 reference1 到 Person 类的新实例之间建立了一个强引用。正是因为

这一个强引用，ARC 会保证 Person 实例被保持在内存中不被销毁。

如果你将同一个 Person 实例也赋值给其他两个变量，该实例又会多出两个强引用:

reference2 = reference1

reference3 = reference1

现在这一个 Person 实例已经有三个强引用了。

如果你通过给其中两个变量赋值 nil 的方式断开两个强引用(包括最先的那个强引用)，只留下一个强引用， Person 实例不会被销

毁:

reference1 = nil

reference2 = nil

在你清楚地表明不再使用这个 Person 实例时，即第三个也就是最后一个强引用被断开时，ARC 会销毁它:

reference3 = nil

// 打印“John Appleseed is being deinitialized”

 

类实例之间的循环强引用

在上面的例子中，ARC 会跟踪你所新创建的 Person 实例的引用数量，并且会在 Person 实例不再被需要时销毁它。 然而，我们

可能会写出一个类实例的强引用数永远不能变成 0 的代码。如果两个类实例互相持有对方的强引用，因而每个实例都让对⽅一直

存在，就是这种情况。这就是所谓的循环强引用。 你可以通过定义类之间的关系为弱引用或⽆主引用，以替代强引用，从而解决

循环强引⽤的问题。具体的过程在解决类实例之间的循环强引用中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有

必要了解一下它是怎样产生的。

下⾯展示了一个不经意产生循环强引用的例子。例子定义了两个类: Person 和 Apartment ，⽤来建模公寓和它其中的居民:

class Person {

    let name: String

    init(name: String) { self.name = name }

    var apartment: Apartment?

    deinit { print("\(name) is being deinitialized") }

}

class Apartment {

    let unit: String

    init(unit: String) { self.unit = unit }

    var tenant: Person?

    deinit { print("Apartment \(unit) is being deinitialized") }

}

每一个 Person 实例有一个类型为 String ，名字为 name 的属性，并有一个可选的初始化为 nil 的 apartment 属性。 apartment 

属性是可选的，因为一个人并不总是拥有公寓。

类似的，每个 Apartment 实例有一个叫 unit ，类型为 String 的属性，并有一个可选的初始化为 nil 的 tenant 属性。 tenant 属性

是可选的，因为一栋公寓并不总是有居民。

这两个类都定义了析构器，用以在类实例被析构的时候输出信息。这让你能够知晓 Person 和 Apartment 的实例是否像预期的那

样被销毁。

接下来的代码片段定义了两个可选类型的变量 john 和 unit4A ，并分别被设定为下面的 Apartment 和 Person 的实例。这两个变

量都被初始化为 nil ，这正是可选类型的优点:

var john: Person?

var unit4A: Apartment?

现在你可以创建特定的 Person 和 Apartment 实例并将赋值给 john 和 unit4A 变量:

john = Person(name: "John Appleseed")

unit4A = Apartment(unit: "4A")

在两个实例被创建和赋值后，下图表现了强引用的关系。变量 john 现在有一个指向 Person 实例的强引用，而变量 unit4A 有⼀

个指向 Apartment 实例的强引用:

现在你能够将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客。注意感叹号是用来展开和访问可选变量 john 

和 unit4A 中的实例，这样实例的属性才能被赋值:

john!.apartment = unit4A

unit4A!.tenant = john

在将两个实例联系在一起之后，强引用的关系如图所示:

 

不幸的是，这两个实例关联后会产生一个循环强引用。 Person 实例现在有了一个指向 Apartment 实例的强引用，而 Apartment 

实例也有了一个指向 Person 实例的强引用。因此，当你断开 john 和 unit4A 变量所持有的强引用时，引用计数并不会降为 0 ，

实例也不会被 ARC 销毁:

john = nil

unit4A = nil

注意，当你把这两个变量设为 nil 时，没有任何一个析构器被调用。循环强引用会一直阻止 Person 和Apartment 类实例的销毁，

这就在你的应用程序中造成了内存泄漏。

在你将 john 和 unit4A 赋值为 nil 后，强引用关系如下图:

Person 和 Apartment 实例之间的强引用关系保留了下来并且不会被断开。

 

解决实例之间的循环强引用

Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题:弱引用(weak reference)和无主引用 (unowned

reference)。

弱引用和无主引用允许循环引用中的一个实例引用另一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。

当其他的实例有更短的⽣命周期时，使用弱引用，也就是说，当其他实例析构在先时。在上面公寓的例子中，很显然一个公寓在

它的生命周期内会在某个时间段没有它的主人，所以一个弱引用就加在公寓类里面，避免循环引用。相比之下，当其他实例有相

同的或者更长生命周期时，请使用无主引用。

 

弱引⽤

弱引用不会对其引用的实例保持强引用，因而不会阻止 ARC 销毁被引用的实例。这个特性阻止了引用变为循环强引用。 声明属

性或者变量时，在前面加上 weak 关键字表明这是一个弱引用。

因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC 会在引用的实例被销毁后自动将其弱引⽤

赋值为 nil 。并且因为弱引用需要在运⾏时允许被赋值为 nil ，所以它们会被定义为可选类型变量，⽽不是常量。

你可以像其他可选值一样，检查弱引用的值是否存在，你将永远不会访问已销毁的实例的引用。

注意

当 ARC 设置弱引用为 nil 时，属性观察不会被触发。

下⾯的例子跟上面 Person 和 Apartment 的例子一致，但是有⼀个重要的区别。这一次， Apartment 的 tenant 属性被声明为弱

引用:

class Person {

    let name: String

    init(name: String) { self.name = name }

    var apartment: Apartment?

    deinit { print("\(name) is being deinitialized") }

}

class Apartment {

    let unit: String

    init(unit: String) { self.unit = unit }

    weak var tenant: Person?

    deinit { print("Apartment \(unit) is being deinitialized") }

}

然后跟之前一样，建立两个变量( john 和 unit4A )之间的强引用，并关联两个实例:

var john: Person?

var unit4A: Apartment?

john = Person(name: "John Appleseed")

unit4A = Apartment(unit: "4A")

john!.apartment = unit4A

unit4A!.tenant = john

现在，两个关联在一起的实例的引用关系如下图所示:

 

Person 实例依然保持对 Apartment 实例的强引用，但是 Apartment 实例只持有对 Person 实例的弱引用。这意味着当你通过把 

john 变量赋值为 nil 而断开其所保持的强引用时，再也没有指向 Person 实例的强引用了:

john = nil

// 打印“John Appleseed is being deinitialized”

由于再也没有指向 Person 实例的强引用，该实例会被销毁，且 tenant 属性会被赋值为 nil :

唯一剩下的指向 Apartment 实例的强引用来自于变量 unit4A 。如果你断开这个强引用，再也没有指向 Apartment 实例的强引⽤

了:

unit4A = nil

// 打印“Apartment 4A is being deinitialized”

由于再也没有指向 Person 实例的强引用，该实例会被销毁:

 

注意

在使用垃圾收集的系统里，弱指针有时用来实现简单的缓冲机制，因为没有强引用的对象只会在内存压⼒触发垃圾收集时才被销

毁。但是在 ARC 中，一旦值的最后一个强引用被移除，就会被立即销毁，这导致弱引用并不适合上面的用途。