Swift 使用自動引用計數（ARC）機制來跟蹤和管理你的應用程序的內存。
引用計數僅僅應用于類的實例。結構體和枚舉類型是值類型，不是引用類型，也不是通過引用的方式存儲和傳遞。
將實例賦值給屬性、常量或變量，都會創建此實例的強引用。只要強引用還在，實例是不允許被銷毀的。
如果兩個類實例互相持有對方的強引用，因而每個實例都讓對方一直存在。這就是所謂的循環強引用。
可以通過定義類之間的關系為弱引用或無主引用，以替代強引用，從而解決循環強引用的問題。
Swift 提供了兩種辦法用來解決在使用類的屬性時所遇到的循環強引用問題：弱引用（weak reference）和無主引用（unowned reference）。
對于生命周期中會變為nil的實例使用弱引用。相反地，對于初始化賦值后再也不會被賦值為nil的實例，使用無主引用。
弱引用（Weak References）
聲明屬性或者變量時，在前面加上weak關鍵字表明這是一個弱引用。
弱引用必須被聲明為變量，表明其值能在運行時被修改。弱引用不能被聲明為常量。
因為弱引用可以沒有值，必須將每一個弱引用聲明為可選類型。在 Swift 中，推薦使用可選類型描述可能沒有值的類型。
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") }
}
var john: Person?
var unit4A: Apartment?
john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")
john!.apartment = unit4A
unit4A!.tenant = john
john = nil
unit4A = nil
無主引用（Unowned References）
和弱引用不同的是，無主引用是永遠有值的。因此，無主引用總是被定義為非可選類型（non-optional type）。
可以在聲明屬性或者變量時，在前面加上關鍵字unowned表示這是一個無主引用。
ARC 無法在實例被銷毀后將無主引用設為nil，因為非可選類型的變量不允許被賦值為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") }
}
var allen: Customer?
allen = Customer(name: "Allen Appleseed")
allen!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
allen = nil
// 打印 “Allen Appleseed is being deinitialized”
// 打印 ”Card #1234567890123456 is being deinitialized”
無主引用以及隱式解析可選屬性（Unowned References and Implicitly Unwrapped Optional Properties）
- 存在著第三種場景，在這種場景中，兩個屬性都必須有值，并且初始化完成后永遠不會為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
}
}
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”
!會引起崩潰，不適合用。這里用可選型或者普通變量都比這個！好
閉包引起的循環強引用（Strong Reference Cycles for Closures）
循環強引用還會發生在將一個閉包賦值給類實例的某個屬性，并且這個閉包體中又使用了這個類實例時。這個閉包體中可能訪問了實例的某個屬性，例如self.someProperty，或者閉包中調用了實例的某個方法，例如self.someMethod()。這兩種情況都導致了閉包“捕獲”self，從而產生了循環強引用。
循環強引用的產生，是因為閉包和類相似，都是引用類型。
Swift 提供了一種優雅的方法來解決這個問題，稱之為閉包捕獲列表（closure capture list）。
在定義閉包時同時定義捕獲列表作為閉包的一部分，通過這種方式可以解決閉包和類實例之間的循環強引用。捕獲列表定義了閉包體內捕獲一個或者多個引用類型的規則。
Swift 有如下要求：只要在閉包內使用self的成員，就要用self.someProperty或者self.someMethod()（而不只是someProperty或someMethod()）。這提醒你可能會一不小心就捕獲了self。
捕獲列表中的每一項都由一對元素組成，一個元素是weak或unowned關鍵字，另一個元素是類實例的引用（例如self）或初始化過的變量（如delegate = self.delegate!）。這些項在方括號中用逗號分開。
在閉包和捕獲的實例總是互相引用并且總是同時銷毀時，將閉包內的捕獲定義為無主引用。
相反的，在被捕獲的引用可能會變為nil時，將閉包內的捕獲定義為弱引用
。弱引用總是可選類型，并且當引用的實例被銷毀后，弱引用的值會自動置為nil。這使我們可以在閉包體內檢查它們是否存在。
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)</\(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>”
paragraph = nil
// 打印 “p is being deinitialized”
關于引用循環，盡量用weak；實在沒辦法，才考了用無主引用。
