注意
引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。
一、自动引用计数的工作机制
- 当你每次创建一个类的新的实例的时候，ARC 会分配一块内存来储存该实例信息。内存中会包含实例的类型信息，以及这个实例所有相关的存储型属性的值。
- 当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。
- 然而，当 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?的变量，用来按照代码片段中的顺序，为新的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 类的新实例被赋值给了
reference1变量，所以reference1到Person类的新实例之间建立了一个强引用。正是因为这一个强引用，ARC 会保证Person实例被保持在内存中不被销毁。如果你将同一个
Person实例也赋值给其他两个变量，该实例又会多出两个强引用：
reference2 = reference1
reference3 = reference1
- 如果你通过给其中两个变量赋值
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") }
}
- 接下来的代码片段定义了两个可选类型的变量
john和unit4A，并分别被设定为下面的Apartment和Person的实例。
var john: Person?
var unit4A: Apartment?
- 现在你可以创建特定的
Person和Apartment实例并将赋值给john和unit4A变量：
john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")
- 现在你能够将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客。
john!.apartment = unit4A
unit4A!.tenant = john
- 此时两个实例互相引用这对方, 产生了一个循环强引用, 因此，当你断开
john和unit4A变量所持有的强引用时，引用计数并不会降为0，实例也不会被 ARC 销毁：
john = nil
unit4A = nil
- 注意，当你把这两个变量设为
nil时，没有任何一个析构函数被调用。循环强引用会一直阻止Person和Apartment类实例的销毁，这就在你的应用程序中造成了内存泄漏。
四、解决实例之间的循环强引用
- Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：弱引用（weak reference）和 无主引用（unowned reference）。
- 弱引用和无主引用允许循环引用中的一个实例引用而另外一个实例不保持强引用。这样实例能够互相引用而不产生循环强引用。
1、弱引用
- 弱引用不会对其引用的实例保持强引用，因而不会阻止 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变量所保持的强引用时，再也没有指向Person实例的强引用了：由于再也没有指向
Person实例的强引用，该实例会被销毁：
john = nil
// 打印 "John Appleseed is being deinitialized"
- 唯一剩下的指向
Apartment实例的强引用来自于变量unit4A。如果你断开这个强引用，再也没有指向Apartment实例的强引用了：
unit4A = nil
// 打印 "Apartment 4A is being deinitialized"
2、无主引用
和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用在其他实例有相同或者更长的生命周期时使用。你可以在声明属性或者变量时，在前面加上关键字
unowned表示这是一个无主引用。无主引用通常都被期望拥有值。不过 ARC 无法在实例被销毁后将无主引用设为
nil，因为非可选类型的变量不允许被赋值为nil。
重点
使用无主引用，你必须确保引用始终指向一个未销毁的实例。
如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。
下面的例子定义了两个类，
Customer和CreditCard，模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系可能会造成循环强引用。一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。为了表示这种关系，
Customer类有一个可选类型的card属性，但是CreditCard类有一个非可选类型的customer属性。此外，只能通过将一个
number值和customer实例传递给CreditCard构造函数的方式来创建CreditCard实例。这样可以确保当创建CreditCard实例时总是有一个customer实例与之关联。由于信用卡总是关联着一个客户，因此将
customer属性定义为无主引用，用以避免循环强引用：
class Customer {
let name: String
var card: CreditCard?
init(name: String) {
self.name = name
}
deinit { print("\(name) is being deinitialized") }
}
class CreditCard {
let number: UInt64
unowned let customer: Customer
init(number: UInt64, customer: Customer) {
self.number = number
self.customer = customer
}
deinit { print("Card #\(number) is being deinitialized") }
}
注意
CreditCard类的number属性被定义为UInt64类型而不是Int类型，以确保number属性的存储量在32位和64位系统上都能足够容纳16位的卡号。
- 下面的代码片段定义了一个叫
john的可选类型Customer变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为nil：
var john: Customer?
- 现在你可以创建
Customer类的实例，用它初始化CreditCard实例，并将新创建的CreditCard实例赋值为客户的card属性：
john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
-
Customer实例持有对CreditCard实例的强引用，而CreditCard实例持有对Customer实例的无主引用。
john = nil
// 打印 "John Appleseed is being deinitialized"
// 打印 "Card #1234567890123456 is being deinitialized"
3、无主引用和隐式解析可选属性
- 上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。
-
Person和Apartment的例子展示了两个属性的值都允许为nil，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。 -
Customer和CreditCard的例子展示了一个属性的值允许为nil，而另一个属性的值不允许为nil，这也可能会产生循环强引用。这种场景最适合通过无主引用来解决。 - 然而，存在着第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后永远不会为
nil。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解析可选属性。 - 这使两个属性在初始化完成后能被直接访问（不需要可选展开），同时避免了循环引用。这一节将为你展示如何建立这种关系。
- 下面的例子定义了两个类，
Country和City，每个类将另外一个类的实例保存为属性。在这个模型中，每个国家必须有首都，每个城市必须属于一个国家。为了实现这种关系，Country类拥有一个capitalCity属性，而City类有一个country属性：
class Country {
let name: String
var capitalCity: City!
init(name: String, capitalName: String) {
self.name = name
self.capitalCity = City(name: capitalName, country: self)
}
}
class City {
let name: String
unowned let country: Country
init(name: String, country: Country) {
self.name = name
self.country = country
}
}
为了建立两个类的依赖关系，
City的构造函数接受一个Country实例作为参数，并且将实例保存到country属性。Country的构造函数调用了City的构造函数。然而，只有Country的实例完全初始化后，Country的构造函数才能把self传给City的构造函数。为了满足这种需求，通过在类型结尾处加上感叹号（
City!）的方式，将Country的capitalCity属性声明为隐式解析可选类型的属性。这意味着像其他可选类型一样，capitalCity属性的默认值为nil，但是不需要展开它的值就能访问它。由于
capitalCity默认值为nil，一旦Country的实例在构造函数中给name属性赋值后，整个初始化过程就完成了。这意味着一旦name属性被赋值后，Country的构造函数就能引用并传递隐式的self。Country的构造函数在赋值capitalCity时，就能将self作为参数传递给City的构造函数。以上的意义在于你可以通过一条语句同时创建
Country和City的实例，而不产生循环强引用，并且capitalCity的属性能被直接访问，而不需要通过感叹号来展开它的可选值：
var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")
// 打印 "Canada's capital city is called Ottawa"
五、闭包引起的循环强引用
- 循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了这个类实例时。这个闭包体中可能访问了实例的某个属性，例如
self.someProperty，或者闭包中调用了实例的某个方法，例如self.someMethod()。这两种情况都导致了闭包“捕获”self，从而产生了循环强引用。 - 循环强引用的产生，是因为闭包和类相似，都是引用类型。当你把一个闭包赋值给某个属性时，你是将这个闭包的引用赋值给了属性。实质上，这跟之前的问题是一样的——两个强引用让彼此一直有效。但是，和两个类实例不同，这次一个是类实例，另一个是闭包。
- 下面的例子为你展示了当一个闭包引用了
self后是如何产生一个循环强引用的。例子中定义了一个叫HTMLElement的类，用一种简单的模型表示HTML文档中的一个单独的元素：
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: () -> String = {
if let text = self.text {
return "<\(self.name)>\(text)"
} else {
return "<\(self.name) />"
}
}
init(name: String, text: String? = nil) {
self.name = name
self.text = text
}
deinit {
print("\(name) is being deinitialized")
}
}
- 实例的
asHTML属性持有闭包的强引用。但是，闭包在其闭包体内使用了self（引用了self.name和self.text），因此闭包捕获了self，这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用。
注意
虽然闭包多次使用了self，它只捕获HTMLElement实例的一个强引用。
六、解决闭包引起的循环强引用
- 在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。
- 捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。
- 跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。
- 应当根据代码关系来决定使用弱引用还是无主引用。
注意
Swift 有如下要求：只要在闭包内使用self的成员，就要用self.someProperty或者self.someMethod()（而不只是someProperty或someMethod()）。这提醒你可能会一不小心就捕获了self。
1、定义捕获列表
捕获列表中的每一项都由一对元素组成，一个元素是
weak或unowned关键字，另一个元素是类实例的引用（例如self）或初始化过的变量（如delegate = self.delegate!）。这些项在方括号中用逗号分开。如果闭包有参数列表和返回类型，把捕获列表放在它们前面：
lazy var someClosure: (Int, String) -> String = {
[unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in
// 这里是闭包的函数体
}
- 如果闭包没有指明参数列表或者返回类型，它们会通过上下文推断，那么可以把捕获列表和关键字
in放在闭包最开始的地方：
lazy var someClosure: Void -> String = {
[unowned self, weak delegate = self.delegate!] in
// 这里是闭包的函数体
}
2、弱引用和无主引用
在闭包和捕获的实例总是互相引用并且总是同时销毁时，将闭包内的捕获定义为
无主引用。相反的，在被捕获的引用可能会变为
nil时，将闭包内的捕获定义为 弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为nil。这使我们可以在闭包体内检查它们是否存在。
注意
如果被捕获的引用绝对不会变为nil，应该用无主引用，而不是弱引用。
- 前面的
HTMLElement例子中，无主引用是正确的解决循环强引用的方法。这样编写HTMLElement类来避免循环强引用：
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: Void -> String = {
[unowned self] in
if let text = self.text {
return "<\(self.name)>\(text)"
} else {
return "<\(self.name) />"
}
}
init(name: String, text: String? = nil) {
self.name = name
self.text = text
}
deinit {
print("\(name) is being deinitialized")
}
}
- 上面的
HTMLElement实现和之前的实现一致，除了在asHTML闭包中多了一个捕获列表。这里，捕获列表是[unowned self]，表示“将self捕获为无主引用而不是强引用”。 - 这一次，闭包以无主引用的形式捕获
self，并不会持有HTMLElement实例的强引用。