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”
