Swift 使用自动引用计数（ARC）机制来跟踪和管理应用程序的内存。通常情况下，Swift 内存管理机制会一直起作用，无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。
引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。
1.自动引用计数的工作机制
自动引用计数的工作机制:
- 创建实例：ARC分配内存来储存该实例的信息（包含类型信息、实例关联的存储属性信息）
- 销毁实例：ARC释放实例所占用的内存，并让释放的内存能挪作他用
- 为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。
2.自动引用计数实践
class Person {
let name: String
init(name: String) {
self.name = name
print("\(name) 开始初始化")
}
deinit {
print("\(name) 被析构")
}
}
// 值会被自动初始化为nil，目前还不会引用到Person类的实例
var reference1: Person?
var reference2: Person?
var reference3: Person?
// 创建Person类的新实例，此时会调用构造函数
reference1 = Person(name: "John Appleseed")
//赋值给其他两个变量，该实例又会多出两个强引用
reference2 = reference1
reference3 = reference1
//断开第一个强引用
reference1 = nil
//断开第二个强引用
reference2 = nil
//断开第三个强引用，此时会调用析构函数
reference3 = nil
以上程序执行输出结果为：
John Appleseed 开始初始化
John Appleseed 被析构
3.类实例之间的循环强引用
在上面的例子中，ARC 会跟踪你所新创建的 Person 实例的引用数量，并且会在 Person 实例不再被需要时销毁它。
然而，我们可能会写出一个类实例的强引用数永远不能变成 0 的代码。如果两个类实例互相持有对方的强引用，因而每个实例都让对方一直存在，就是这种情况。这就是所谓的循环强引用。
3.1 循环引用实例
下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：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 的实例。这两个变量都被初始化为 nil :
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
此时的强引用关系如下图所示：
当这两个实例关联后会产生一个循环强引用。Person 实例现在有了一个指向 Apartment 实例的强引用，而 Apartment 实例也有了一个指向 Person 实例的强引用。因此，当你断开 john 和 unit4A 变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：
john = nil
unit4A = nil
注意，当把这两个变量设为
nil时，没有任何一个析构器被调用。循环强引用会一直阻止Person和Apartment类实例的销毁，这就在应用程序中造成了内存泄漏。
在将 john 和 unit4A 赋值为 nil 后，强引用关系如下图：
Person 和 Apartment 实例之间的强引用关系保留了下来并且不会被断开。
3.2 解决实例之间的循环强引用
Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：
- 弱引用
- 无主引用
弱引用和无主引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。
当其他的实例有更短的生命周期时，使用弱引用。相反的，当其他实例有相同的或者更长生命周期时，使用无主引用。
3.2.1 弱引用
弱引用不会对其引用的实例保持强引用，ARC会在引用的实例被销毁后自动将其弱引用赋值为 nil(弱引用的实例要被定义为 可选变量)，用 weak 关键字表明弱引用
当 ARC 设置弱引用为
nil时，属性观察不会被触发。可以像其他可选值一样，检查弱引用的值是否存在，这样可以避免访问已销毁的实例的引用。
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 实例的强引用，把 john 变量赋值为 nil 而断开其所保持的强引用:
john = nil
// 打印“John Appleseed is being deinitialized”
由于再也没有指向 Person 实例的强引用，该实例会被销毁，且 tenant 属性会被赋值为 nil：
唯一剩下的指向 Apartment 实例的强引用来自于变量 unit4A。如果你断开这个强引用，再也没有指向 Apartment 实例的强引用了：
unit4A = nil
// 打印“Apartment 4A is being deinitialized”
由于再也没有指向 Apartment 实例的强引用，该实例会被销毁：
3.2.2 无主引用
无主引用不会牢牢保持住引用的实例，和弱引用不同的是：
- 无主引用在其他实例有相同或者更长的生命周期时使用
- 在被声明的属性或者变量（非可选类型）前面加上关键字
unowned表示无主引用 - ARC 无法在实例被销毁后将无主引用设为
nil
使用无主引用，你必须确保引用始终指向一个未销毁的实例。
如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。
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") }
}
下面的代码片段定义了一个叫 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 的无主引用，当你断开 john 变量持有的强引用时，再也没有指向 Customer 实例的强引用了：
由于再也没有指向 Customer 实例的强引用，该实例被销毁了。其后，再也没有指向 CreditCard 实例的强引用，该实例也随之被销毁了：
john = nil
// 打印“John Appleseed is being deinitialized”
// 打印“Card #1234567890123456 is being deinitialized”
3.2.3 无主引用和隐式解包可选值属性
上面的例子涵盖了两种常用的需要打破循环强引用的场景:
- 弱引用: 两个属性的值都允许为
nil，并会潜在的产生循环强引用 - 无主引用: 一个属性的值允许为
nil，而另一个属性的值不允许为nil，这也可能会产生循环强引用
然而，存在着第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后永远不会为 nil。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解包可选值属性。
这使两个属性在初始化完成后能被直接访问（不需要可选解包），同时避免了循环引用
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
}
}
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”
4.闭包的循环强引用
循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性，例如 self.someProperty，或者闭包中调用了实例的某个方法，例如self.someMethod()。这两种情况都导致了闭包 “捕获” self，从而产生了循环强引用。
4.1 闭包循环强引用实例
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: () -> String = {
if let text = self.text {
return "<\(self.name)>\(text)</\(self.name)>"
} else {
return "<\(self.name) />"
}
}
init(name: String, text: String? = nil) {
self.name = name
self.text = text
}
deinit {
print("\(name) is being deinitialized")
}
}
创建实例并打印消息：
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// 打印“<p>hello, world</p>”
然而上面写的 HTMLElement 类产生了类实例和作为 asHTML 默认值的闭包之间的循环强引用。循环强引用如下图所示：
实例的
asHTML属性持有闭包的强引用。但是，闭包在其闭包体内使用了self（引用了self.name和self.text），因此闭包捕获了self，这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用
如果设置 paragraph 变量为 nil，打破它持有的 HTMLElement 实例的强引用，HTMLElement 实例和它的闭包都不会被销毁，也是因为循环强引用：
paragraph = nil
HTMLElement 的析构器中的消息并没有被打印，证明了 HTMLElement 实例并没有被销毁。
4.2 解决闭包的循环强引用
在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。
捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。
Swift 有如下要求：只要在闭包内使用
self的成员，就要用self.someProperty或者self.someMethod()（而不只是someProperty或someMethod()）。这提醒你可能会一不小心就捕获了self。
4.2.1 定义捕获列表
捕获列表中的每一项都由一对元素组成:
- 一个元素是
weak或unowned关键字， - 另一个元素是类实例的引用（例如 self）或初始化过的变量（如
delegate = self.delegate）。
这些项在方括号中用逗号分开，如果闭包有参数列表和返回类型，把捕获列表放在它们前面：
lazy var someClosure = {
[unowned self, weak delegate = self.delegate]
(index: Int, stringToProcess: String) -> String in
// 这里是闭包的函数体
}
如果闭包没有指明参数列表或者返回类型，它们会通过上下文推断，那么可以把捕获列表和关键字 in 放在闭包最开始的地方：
lazy var someClosure = {
[unowned self, weak delegate = self.delegate] in
// 这里是闭包的函数体
}
4.2.2 弱引用和无主引用
在闭包和捕获的实例总是互相引用并且总是同时销毁时，将闭包内的捕获定义为 无主引用。
在被捕获的引用可能会变为 nil 时，将闭包内的捕获定义为 弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为 nil
如果被捕获的引用绝对不会变为 nil，应该用无主引用，而不是弱引用。
前面的 HTMLElement 例子中，无主引用是正确的解决循环强引用的方法。这样编写 HTMLElement 类来避免循环强引用：
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: () -> String = {
// 将 self 捕获为无主引用而不是强引用
[unowned self] in
if let text = self.text {
return "<\(self.name)>\(text)</\(self.name)>"
} else {
return "<\(self.name) />"
}
}
init(name: String, text: String? = nil) {
self.name = name
self.text = text
}
deinit {
print("\(name) is being deinitialized")
}
}
和之前一样，我们可以创建并打印 HTMLElement 实例：
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// 打印“<p>hello, world</p>”
使用捕获列表后引用关系如下图所示：
这一次，闭包以无主引用的形式捕获 self，并不会持有 HTMLElement 实例的强引用。如果将 paragraph 赋值为 nil，HTMLElement 实例将会被销毁，并能看到它的析构器打印出的消息：
paragraph = nil
// 打印“p is being deinitialized”
