1.简介
Swift 使用自动引用计数(ARC)机制来跟踪和管理内存。ARC 会在类的实例不再被使用时，自动释放其占用的内存。文章将介绍:
- 自动引用计数的工作机制
- 自动引用计数实践
- 类实例之间的循环强引用
- 解决实例之间的循环强引用
- 闭包引起的循环强引用
- 解决闭包引起的循环强引用
Tips: 引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。
2.自动引用计数的工作机制
当每次创建一个类的新的实例的时候，ARC 会分配一块内存来存储该实例信息。内存中会包含实例的类型信息，以及这个实例所有相关的存储型属性的值。
此外，当实例不再被使用时， ARC 释放实例所占用的内存，确保不再使用的实例不会一直占用内存空间。
然而，当 ARC 收回和释放了正在使用中的实例，那么该实例的属性和方法将不能再被访问和调用。如果试图访问，程序可能会崩溃。
ARC 会跟踪计算每一个实例正在被多少属性，常量和变量引用，不为0则不会销毁该实例。
3.自动引用计数实践
下面的例子展示自动引用计数的工作机制。例子以一个简单的 Person 类开始，
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会销毁它
reference1 = nil
//打印 "John Appleseed is being deinitialized"
4.类实例之间的循环强引用
在上面的例子中， ARC 会跟踪你所新创建的 Person 实例的引用数量，并且会在 Person 实例不再被需要时销毁它。
然而，当两个类实例互相持有对方的强引用，每个实例都让对方一直存在，即为强循环引用。
你可以通过定义类之间的关系为弱引用活无主引用，以替换强引用，从而解决强引用的问题。下面例子展示了强引用循环:
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 实例有个类型为 Stirng， 名字为name 属性，并有一个可选的初始化为 nil 的 apartment 属性。apartment 属性是可选的，因为一个人并不是总是拥有公寓。
类似的,每个 Apartment实例有一个叫 unit， 类型为 String 的属性， 并有一个可选的初始化为 nil 的 tenant 属性。因为公寓中可能没有居民。
两个类都定义了析构函数，用以在类实例被析构时输出信息。
接下来定义可选类型 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 类实例的销毁，造成内存泄露。
Person 和 Apartment 实例之间的强引用关系保留了下来并且不会被断开。
5.解决实例之间的循环强引用
Swift 中存在两种方法解决在使用类的属性时所遇到的循环强引用问题:弱引用(weak reference) 和无主引用(unowned reference)。
弱引用和无主引用允许循环引用中的一个实例引用而另外一个实例不保持强引用。这样实例能够互相引用而不产生循环强引用。
当其他的实例有更短的生命周期时，使用弱引用，也就是说，当其他实例析构在先时。在例子中，公寓在生命周期内会在某个时间段没有它的主人，所以将弱引用加在公寓类里面，避免循环引用。当其他实例有相同或者更长的生命周期时，使用无主引用。
- 弱引用
弱引用不会对其引用的实例保持强引用，因而不会阻止 ARC 销毁被引用的实例。这个特性阻止了引用变为循环强引用。声明属性或变量时，在前面加上 week 关键字表明这是一个弱引用。
因为弱引用不会保持所引用的实例，因而不会阻止 ARC 销毁被引用的实例。因此， ARC 会在引用的实例被销毁后自动将其赋值为 nil。并且因为弱引用可以允许它们的值在运行时被赋值为 nil， 所以它们会被定义为可选类型变量，而不是常量。
你可以像其它可选值一样，检查弱引用的值是否存在，你将永远不会访问已经销毁的实例的引用
Tips: 当 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 {parint("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 实例的强引用了:
由于再也没有指向 Apartment 实例的强引用，该实例也会被销毁:
unit4A = nil
//打印 "Apartment 4A is being deinitialized"
Tips: 在使用垃圾回收的系统里，弱指针有时用来实现简单的缓冲机制，因为没有强引用的对象只会在内存压力触发垃圾收集时才被销毁。但是在 ARC 中，一旦值的最后一个强引用被移除，就会被立即销毁，这导致弱引用并不适合上面的用途。
- 无主引用
和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用在其他实例有相同或者更长生命周期时使用。你可以在声明属性或者变量时，在前面加上关键字 unowned 表示这是一个无主引用。
无主引用通常都被期望拥有值。不过 ARC 无法在实例被销毁后将无主引用设为 nil,因为非可选类型的变量不允许被赋值为 nil。
Tips: 使用无主引用，你必须确保引用始终指向一个未销毁的实例。如果你视图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。
下面的例子定义了两个类， Customer 和 CreditCard， 模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系会造成循环强引用。
Customer 和 CreditCard 之间的关系与前面弱引用例子中 Apartment 和 Person 的关系略微不同。在这个数据模型中，一个客户可能有或者没有信用卡，但是每一张信用卡总是关联着一个客户。为了表示这种关系， 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")
}
}
Tips: 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 实例的无主引用。由于 customer 的无主引用，当你断开 john 变量持有的强引用时，再也没有指向 customer 实例的强引用了:
由于再也没有指向 Customer 实例的强引用，该实例就被销毁了。其后，再也没有指向 CreditCard 实例的强引用，该实例也随之被销毁了:
john = nil
//打印 "John Appleseed is being deinitialized"
//打印 "Card #1234567890123456 is being deinitialized"
最后的代码展示了在 john 变量被设为 nil 后 Customer 实例和 CreditCard 实例的构造函数都打印出了销毁信息。
Tips: 上面的例子展示了如何使用安全的无主引用。对于需要禁用运行时的安全检查的情况(例如，出于性能方面的原因)，Swift 还提供了不安全的无主引用。与所有不安全的操作一样，你需要负责检查代码以确保其安全性。你可以通过unowned(unsafe)来声明不安全无主引用。如果你试图在实例被销毁后，访问该实例的不安全无主引用，你的程序会尝试访问该实例之前所在的内存地址，这是一个不安全的操作。
- 无主引用以及隐式解析可选属性
上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。
Person 和 Apartment 的例子展示了两个属性的值都允许为 nil， 并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。
Customer 和 CreditCard 的例子展示了一个属性的值允许为 nil， 而另一个属性的值不允许为 nil， 这也可能会产生循环强引用。这种场景最适合通过无主引用解决。
然而，存在这第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后永远不会为 nil。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解析可选属性。
这使两个属性在初始化完成后能被直接访问(不需要可选展开)，同时避免了循环引用。这一节将为你展示如何建立这种关系。
下面的例子定义了两个类， Country 和 City， 每个类将另外一个类的实例保持为属性。在这个模型中，每个国家必须有首都，每个城市必须属于一个国家。为了实现这种关系， Country 类拥有一个 capitalCity 属性，而 City 类有一个 Country 属性:
class Coutry{
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: Stirng
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"
在上面的例子中，使用隐式解析可选值意味着满足了类的构造函数的两个构造构造阶段的要求。capitalCity 属性在初始化完成后，能像非可选值一样使用和存取，同时还避免了循环强引用。
- 闭包引起的循环强引用
--
前面我们演示了循环强引用是在两个类实例属性互相保持对方的强引用时产生的，还知道了如何使用弱引用和无主引用来打破这些循环强引用。
循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体重又使用了这个类实例时。这个闭包体中可能访问了实例的某个属性，例如self.someProperty，或者闭包中调用了实例的某个方法，例如self.someMethod()。这两种情况都导致了闭包"捕获"self， 从而产生了循环强引用。
循环强引用的产生，是因为闭包和类相似，都是引用类型。当你把一个闭包赋值给某个属性时，你是将这个闭包的引用赋值给了属性。实质上，这跟之前的问题是一样的----两个强引用让彼此一直有效。但是，和两个类实例不同，这次一个是实例，另一个是闭包。
Swift 提供了一种优雅的方法来解决这个问题，称之为闭包捕获列表（closure capture list）。同样的，在学习如何使用闭包捕获列表打破循环强引用之前，先来了解一下这里的循环强引用是如何产生的。
下面的例子展示了当一个闭包引用了 self后是如何产生一个循环强引用的。例子中定义了一个叫 HTMLElement 的类，用一种简单的模型表示 HTML 文档中的单独的元素：
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: Void -> String = {
if let text = self.text {
return "<\(self.name)>\(text)</\(self.name)>"
}else {
return "<\(self.name)/>"
}
}
init(name: String,text: Stirng? = nil){
self.name = name
self.text = text
}
deinit{
print("\(name) is being deinitialized")
}
}
HTMLElement 定义了一个 name 属性来表示这个元素的名称，例如代表头部元素的“h1”，代表段落的“p”，或者代表换行的“br”。HTMLElement 还定义了一个可选的属性 text， 用来设置 HTML 元素呈现的文本。
除了上面的两个属性，HTMLElement 还定义了一个 lazy 属性 asHTML。这个属性引用了一个将 name 和 text 组合成 HTML 字符串片段的闭包。该属性是 Void -> String 类型，或者可以理解为“一个没有参数，返回 String 的函数”。
默认情况下，闭包赋值给了asHTML属性，这个闭包返回一个代表 HTML 标签的字符串。如果text值存在，该标签就包含可选值text；如果text不存在，该标签就不包含文本。对于段落元素，根据 text是"some text"还是 nil，闭包会返回“<p>some text</p>”或者“<p/>”。
可以像实例方法那样去命名、使用asHTML属性。然而，由于asHTML是闭包而不是实例方法，如果你想改变特定 HTML 元素的处理方式的话，可以用自定义的闭包来取代默认值。
例如，可以将一个闭包赋值给asHTML属性，这个闭包能在text属性是nil时使用默认文本，这是为了避免返回一个空的 HTML 标签：
let heading = HTMLElement(name: "h1")
let defaultText = "some default text"
heading.asHTML = {
return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
}
print(heading.asHTML())
//打印"<h1>some default text</h1>"
Tips：asHTML声明为 lazy 属性，因为只有当元素确实需要被处理为 HTML 输出的字符串时，才需要使用asHTML。也就是说，在默认的闭包中可以使用self，因为只有当初始化完成以及self确实存在后，才能访问 lazy 属性。
HTMLElement类只提供了一个构造函数，通过name和text（如果有的 话）参数来初始化一个新元素。该类也定义了一个析构函数，当HTMLElement实例被销毁时，打印一条消息。
var paragraph: HTMLElement? = HTMLElement(name: "p",text: "hello,world")
print(paragraph!.asHTML())
//打印 “<p>hello,world</p>”
Tips： 上面的paragraph变量定义为可选类型的HTMLElement，因此我们可以赋值nil给它来演示循环强引用。
上面写的HTMLElement类产生了类实例和作为asHTML默认值的闭包之间的循环强引用。循环想引用关系如下：
实例的
asHTML属性持有闭包强引用。但是，闭包在其闭包体内使用了self（引用了self.name 和 self.text），因此闭包捕获了self，这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用。Tips：虽然闭包多次使用了
self，它只捕获HTMLElement实例的一个强引用。如果设置
paragraph变量为nil，打破它持有的HTMLElement实例的强引用，HTMLElement实例和它的闭包都不会被销毁，也是因为循环强引用：
paragraph = nil
注意，HTMLElement的析构函数中的消息并没有被打印，证明了HTMLElement实例并没有被销毁。
7.解决闭包引起的循环强引用
在定义闭包时同事定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。
Tips：Swift 有如下要求：只要在闭包内使用 self 的成员，就要用self.someProperty或者self.someMethod()（而不只是someProperty或someMethod（））。这提醒你可能会一不小心就捕获了self。
- 定义捕获列表
捕获列表中的每一项都由一对元素组成，一个元素是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 someClouse: Void -> String = {
[unowned self, weak delegate = self.delegate!]in
//这里是闭包的函数体
}
- 弱引用和无主引用
在闭包和捕获的实例总是互相引用并且总是同时销毁时，将闭包内的捕获定义为无主引用。
相反的，在被捕获的引用可能会变成nil时，将闭包内的捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为nil。这使我们可以在闭包内检查它们是否存在。
Tips： 如果被捕获的引用绝对不会变为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)</\(name)>"
}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捕获为无主引用而不是强引用”。
和之前一样，我们可以创建并打印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”
