Swift 使用自動引用計數(ARC)機制來跟蹤和管理你的應用程序的內存涨岁。通常情況下梢薪，Swift 內存管理機制會一直起作用秉撇，你無須自己來考慮內存的管理琐馆。ARC 會在類的實例不再被使用時啡捶，自動釋放其占用的內存瞎暑。

然而在少數情況下了赌，為了能幫助你管理內存，ARC 需要更多的袄秩，代碼之間關系的信息之剧。本章描述了這些情況背稼，并且為你示范怎樣才能使 ARC 來管理你的應用程序的所有內存蟹肘。在 Swift 使用 ARC 與在 Obejctive-C 中使用 ARC 非常類似帘腹。

注意
引用計數僅僅應用于類的實例阳欲。結構體和枚舉類型是值類型胸完，不是引用類型赊窥，也不是通過引用的方式存儲和傳遞锨能。

自動引用計數的工作機制

當你每次創(chuàng)建一個類的新的實例的時候址遇，ARC 會分配一塊內存來儲存該實例信息倔约。內存中會包含實例的類型信息浸剩，以及這個實例所有相關的存儲型屬性的值绢要。

此外重罪，當實例不再被使用時剿配，ARC 釋放實例所占用的內存惨篱，并讓釋放的內存能挪作他用砸讳。這確保了不再被使用的 實例簿寂，不會一直占用內存空間常遂。

然而克胳，當 ARC 收回和釋放了正在被使用中的實例漠另，該實例的屬性和方法將不能再被訪問和調用。實際上，如果你 試圖訪問這個實例肤频，你的應用程序很可能會崩潰宵荒。

為了確保使用中的實例不會被銷毀骇扇，ARC 會跟蹤和計算每一個實例正在被多少屬性少孝，常量和變量所引用稍走。哪怕實例的引用數為1婿脸，ARC 都不會銷毀這個實例狐树。

為了使上述成為可能抑钟，無論你將實例賦值給屬性在塔、常量或變量蛔溃，它們都會創(chuàng)建此實例的強引用贺待。之所以稱之為“強”引用麸塞，是因為它會將實例牢牢地保持住喘垂，只要強引用還在正勒，實例是不允許被銷毀的章贞。

自動引用計數實踐

下面的例子展示了自動引用計數的工作機制鸭限。例子以一個簡單的 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 類有一個構造函數朴皆，此構造函數為實例的 name 屬性賦值遂铡，并打印一條消息以表明初始化過程生效扒接。 on 類也擁有一個析構函數钾怔，這個析構函數會在實例被銷毀時打印一條消息蒂教。

接下來的代碼片段定義了三個類型為 Person? 的變量，用來按照代碼片段中的順序蜓谋，為新的 Person 實例建立多個引用桃焕。由于這些變量是被定義為可選類型( Person? 让网，而不是 Person )溃睹，它們的值會被自動初始化為 nil ，目 前還不會引用到 Person 類的實例胰坟。

var reference1: Person?
var reference2: Person?
var reference3: Person?

現在你可以創(chuàng)建 Person 類的新實例因篇，并且將它賦值給三個變量中的一個:

reference1 = Person(name: "John Appleseed")
// 打印 "John Appleseed is being initialized”

應當注意到當你調用 Person 類的構造函數的時候， “John Appleseed is being initialized” 會被打印出來笔横。由 此可以確定構造函數被執(zhí)行竞滓。

由于 Person 類的新實例被賦值給了 reference1 變量，所以 reference1 到 Person 類的新實例之間建立了一個強引用吹缔。正是因為這一個強引用，ARC 會保證 Person 實例被保持在內存中不被銷毀厢塘。

如果你將同一個 Person 實例也賦值給其他兩個變量莉御，該實例又會多出兩個強引用:

reference2 = reference1
reference3 = reference1

現在這一個 Person 實例已經有三個強引用了。

如果你通過給其中兩個變量賦值 nil 的方式斷開兩個強引用(包括最先的那個強引用)俗冻，只留下一個強引用礁叔， Person 實例不會被銷毀:

reference1 = nil
reference2 = nil

在你清楚地表明不再使用這個 Person 實例時，即第三個也就是最后一個強引用被斷開時迄薄，ARC 會銷毀它:

reference3 = nil
// 打印 “John Appleseed is being deinitialized”

類實例之間的循環(huán)強引用

在上面的例子中琅关，ARC 會跟蹤你所新創(chuàng)建的 Person 實例的引用數量，并且會在 Person 實例不再被需要時銷毀它讥蔽。

然而涣易，我們可能會寫出一個類實例的強引用數永遠不能變成 0 的代碼。如果兩個類實例互相持有對方的強引用冶伞，因而每個實例都讓對方一直存在新症，就是這種情況。這就是所謂的循環(huán)強引用响禽。

你可以通過定義類之間的關系為弱引用或無主引用徒爹，以替代強引用荚醒，從而解決循環(huán)強引用的問題。不管怎樣隆嗅，在你學習怎樣解決循環(huán)強引用之前界阁，很有必要了解一 下它是怎樣產生的。

下面展示了一個不經意產生循環(huán)強引用的例子胖喳。例子定義了兩個類: 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") }
 }

每一個 Person 實例有一個類型為 String ，名字為 name 的屬性丽焊，并有一個可選的初始化為 nil 的 apartment 屬性较剃。 apartment 屬性是可選的，因為一個人并不總是擁有公寓技健。

類似的写穴，每個 Apartment 實例有一個叫 unit ，類型為 String 的屬性凫乖，并有一個可選的初始化為 nil 的 tenant 屬性确垫。 tenant 屬性是可選的，因為一棟公寓并不總是有居民帽芽。

這兩個類都定義了析構函數删掀，用以在類實例被析構的時候輸出信息。這讓你能夠知曉 Person 和 Apartment 的實例 是否像預期的那樣被銷毀导街。

接下來的代碼片段定義了兩個可選類型的變量 john 和 unit4A 披泪，并分別被設定為下面的 Apartment 和 Person 的 實例。這兩個變量都被初始化為 nil 搬瑰，這正是可選類型的優(yōu)點:

var john: Person?
var unit4A: Apartment?

現在你可以創(chuàng)建特定的 Person 和 Apartment 實例并將賦值給 john 和 unit4A 變量:

john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

在兩個實例被創(chuàng)建和賦值后款票，下圖表現了強引用的關系。變量 john 現在有一個指向 Person 實例的強引用泽论，而變量 unit4A 有一個指向 Apartment 實例的強引用:

現在你能夠將這兩個實例關聯(lián)在一起艾少，這樣人就能有公寓住了，而公寓也有了房客翼悴。注意感嘆號是用來展開和訪 問可選變量 john 和 unit4A 中的實例缚够，這樣實例的屬性才能被賦值:

john!.apartment = unit4A
unit4A!.tenant = john

不幸的是，這兩個實例關聯(lián)后會產生一個循環(huán)強引用鹦赎。 Person 實例現在有了一個指向 Apartment 實例的強引 用，而 Apartment 實例也有了一個指向 Person 實例的強引用古话。因此雏吭，當你斷開 john 和 unit4A 變量所持有的強引用時，引用計數并不會降為 0 陪踩，實例也不會被 ARC 銷毀:

john = nil
unit4A = nil

注意杖们，當你把這兩個變量設為 nil 時悉抵，沒有任何一個析構函數被調用。循環(huán)強引用會一直阻止 Person 和 Apartment 類實例的銷毀胀莹，這就在你的應用程序中造成了內存泄漏基跑。

Person 和 Apartment 實例之間的強引用關系保留了下來并且不會被斷開婚温。

解決實例之間的循環(huán)強引用

Swift 提供了兩種辦法用來解決你在使用類的屬性時所遇到的循環(huán)強引用問題:弱引用(weak reference)和無主引用(unowned reference)描焰。

弱引用和無主引用允許循環(huán)引用中的一個實例引用而另外一個實例不保持強引用。這樣實例能夠互相引用而不產生循環(huán)強引用栅螟。

當其他的實例有更短的生命周期時荆秦，使用弱引用，也就是說力图，當其他實例析構在先時步绸。在上面公寓的例子中，很顯然一個公寓在它的生命周期內會在某個時間段沒有它的主人吃媒，所以一個弱引用就加在公寓類里面瓤介，避免循環(huán)引用。相比之下赘那，當其他實例有相同的或者更長生命周期時刑桑，請使用無主引用。

弱引用

弱引用不會對其引用的實例保持強引用募舟，因而不會阻止 ARC 銷毀被引用的實例祠斧。這個特性阻止了引用變?yōu)檠h(huán)強引用。聲明屬性或者變量時拱礁，在前面加上 weak 關鍵字表明這是一個弱引用琢锋。

因為弱引用不會保持所引用的實例，即使引用存在呢灶，實例也有可能被銷毀吴超。因此，ARC 會在引用的實例被銷毀后 自動將其賦值為 nil 鸯乃。并且因為弱引用可以允許它們的值在運行時被賦值為 nil 鲸阻，所以它們會被定義為可選類型變量，而不是常量飒责。

你可以像其他可選值一樣赘娄，檢查弱引用的值是否存在，你將永遠不會訪問已銷毀的實例的引用宏蛉。

注意
當 ARC 設置弱引用為 nil 時遣臼，屬性觀察不會被觸發(fā)。

下面的例子跟上面 Person 和 Apartment 的例子一致拾并，但是有一個重要的區(qū)別揍堰。這一次鹏浅， 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 )之間的強引用屏歹，并關聯(lián)兩個實例:

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”

上面的兩段代碼展示了變量 john 和 unit4A 在被賦值為 nil 后， Person 實例和 Apartment 實例的析構函數都打印出“銷毀”的信息友浸。這證明了引用循環(huán)被打破了峰尝。

注意
在使用垃圾收的系統(tǒng)里，弱指針有時用來實現簡單的緩沖機制收恢，因為沒有強引用的對象只會在內存壓力觸發(fā)垃圾收集時才被銷毀武学。但是在 ARC 中，一旦值的最后一個強引用被移除伦意，就會被立即銷毀火窒，這導致弱引用并不適 合上面的用途。

無主引用

和弱引用類似默赂，無主引用不會牢牢保持住引用的實例沛鸵。和弱引用不同的是，無主引用在其他實例有相同或者更長 的生命周期時使用缆八。你可以在聲明屬性或者變量時曲掰，在前面加上關鍵字 unowned 表示這是一個無主引用。

無主引用通常都被期望擁有值奈辰。不過 ARC 無法在實例被銷毀后將無主引用設為 nil 栏妖，因為非可選類型的變量不允許被賦值為 nil 。

重要
使用無主引用奖恰，你必須確保引用始終指向一個未銷毀的實例吊趾。
如果你試圖在實例被銷毀后，訪問該實例的無主引用瑟啃，會觸發(fā)運行時錯誤论泛。

下面的例子定義了兩個類， Customer 和 CreditCard 蛹屿，模擬了銀行客戶和客戶的信用卡屁奏。這兩個類中，每一個都將另外一個類的實例作為自身的屬性错负。這種關系可能會造成循環(huán)強引用坟瓢。

Customer 和 CreditCard 之間的關系與前面弱引用例子中 Apartment 和 Person 的關系略微不同勇边。在這個數據模型中，一個客戶可能有或者沒有信用卡折联，但是一張信用卡總是關聯(lián)著一個客戶粒褒。為了表示這種關系， Customer 類有一個可選類型的 card 屬性诚镰，但是 CreditCard 類有一個非可選類型的 customer 屬性奕坟。

此外，只能通過將一個 number 值和 customer 實例傳遞給 CreditCard 構造函數的方式來創(chuàng)建 CreditCard 實例怕享。這樣可以確保當創(chuàng)建 CreditCard 實例時總是有一個 customer 實例與之關聯(lián)执赡。

由于信用卡總是關聯(lián)著一個客戶镰踏，因此將 customer 屬性定義為無主引用函筋，用以避免循環(huán)強引用:

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 位系統(tǒng)上都能足夠容納 16 位的卡號奠伪。

下面的代碼片段定義了一個叫 john 的可選類型 Customer 變量跌帐，用來保存某個特定客戶的引用。由于是可選類 型绊率，所以變量被初始化為 nil :

var john: Customer?

現在你可以創(chuàng)建 Customer 類的實例谨敛，用它初始化 CreditCard 實例，并將新創(chuàng)建的 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 實例的構造函數都打印出了“銷毀”的信息。

注意
上面的例子展示了如何使用安全的無主引用菱父。對于需要禁用運行時的安全檢查的情況(例如颈娜，出于性能方面的原因)，Swift 還提供了不安全的無主引用浙宜。與所有不安全的操作一樣官辽，你需要負責檢查代碼以確保其安全性。 你 可以通過 unowned(unsafe) 來聲明不安全無主引用粟瞬。如果你試圖在實例被銷毀后同仆，訪問該實例的不安全無主引用，你的程序會嘗試訪問該實例之前所在的內存地址亩钟，這是一個不安全的操作乓梨。**

無主引用以及隱式解析可選屬性

上面弱引用和無主引用的例子涵蓋了兩種常用的需要打破循環(huán)強引用的場景鳖轰。

Person 和 Apartment 的例子展示了兩個屬性的值都允許為 nil ，并會潛在的產生循環(huán)強引用扶镀。這種場景最適合用 弱引用來解決蕴侣。

Customer 和 CreditCard 的例子展示了一個屬性的值允許為 nil ，而另一個屬性的值不允許為 nil 臭觉，這也可能會 產生循環(huán)強引用社证。這種場景最適合通過無主引用來解決。

然而比庄，存在著第三種場景滔迈，在這種場景中，兩個屬性都必須有值什乙，并且初始化完成后永遠不會為 nil 挽封。在這種場 景中，需要一個類使用無主屬性臣镣，而另外一個類使用隱式解析可選屬性辅愿。

這使兩個屬性在初始化完成后能被直接訪問(不需要可選展開)，同時避免了循環(huán)引用忆某。這一節(jié)將為你展示如何建立這種關系点待。

下面的例子定義了兩個類，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 的構造函數车吹。

以上的意義在于你可以通過一條語句同時創(chuàng)建 Country 和 City 的實例，而不產生循環(huán)強引用醋闭，并且 的屬性能被直接訪問窄驹，而不需要通過感嘆號來展開它的可選值:

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 屬性在 初始化完成后乐埠，能像非可選值一樣使用和存取，同時還避免了循環(huán)強引用瑟曲。

閉包引起的循環(huán)強引用

前面我們看到了循環(huán)強引用是在兩個類實例屬性互相保持對方的強引用時產生的饮戳，還知道了如何用弱引用和無主引用來打破這些循環(huán)強引用。

循環(huán)強引用還會發(fā)生在當你將一個閉包賦值給類實例的某個屬性洞拨，并且這個閉包體中又使用了這個類實例時。這 個閉包體中可能訪問了實例的某個屬性负拟，例如 self.someProperty 烦衣，或者閉包中調用了實例的某個方法，例如 f.someMethod() 掩浙。這兩種情況都導致了閉包“捕獲” self 花吟，從而產生了循環(huán)強引用。

循環(huán)強引用的產生厨姚，是因為閉包和類相似衅澈，都是引用類型。當你把一個閉包賦值給某個屬性時谬墙，你是將這個閉包的引用賦值給了屬性今布。實質上，這跟之前的問題是一樣的——兩個強引用讓彼此一直有效拭抬。但是部默，和兩個類實例不同，這次一個是類實例造虎，另一個是閉包傅蹂。

Swift 提供了一種優(yōu) 的方法來解決這個問題，稱之為 閉包捕獲列表 (closure capture list)。同樣的份蝴，在學 習如何用閉包捕獲列表打破循環(huán)強引用之前犁功，先來了解一下這里的循環(huán)強引用是如何產生的，這對我們很有幫助婚夫。

下面的例子為你展示了當一個閉包引用了 self 后是如何產生一個循環(huán)強引用的波桩。例子中定義了一個叫 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: String? = 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 蠢络，閉包會返回 "some text" 或者 " " 。

可以像實例方法那樣去命名迟蜜、使用 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>”

注意
asHTML 聲明為 lazy 屬性兢交，因為只有當元素確實需要被處理為 HTML 輸出的字符串時薪捍，才需要使用 asHTML 。也就是說，在默認的閉包中可以使用 self 酪穿，因為只有當初始化完成以及 self 確實存在后凳干，才能訪問 lazy 屬性。

HTMLElement 類只提供了一個構造函數被济，通過 name 和 text (如果有的話)參數來初始化一個新元素救赐。該類也定義了一個析構函數，當 HTMLElement 實例被銷毀時只磷，打印一條消息经磅。

下面的代碼展示了如何用 HTMLElement 類創(chuàng)建實例并打印消息:

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world") print(paragraph!.asHTML())
// 打印 “<p>hello, world</p>”

注意
上面的 paragraph 變量定義為可選類型的 HTMLElement ，因此我們可以賦值 nil 給它來演示循環(huán)強引用钮追。

不幸的是预厌，上面寫的 HTMLElement 類產生了類實例和作為 asHTML 默認值的閉包之間的循環(huán)強引用。

實例的 asHTML 屬性持有閉包的強引用元媚。但是轧叽，閉包在其閉包體內使用了 self (引用了 self.name 和 self.text )，因此閉包捕獲了 self 刊棕，這意味著閉包又反過來持有了 HTMLElement 實例的強引用炭晒。這樣兩個對象就產生了循環(huán)強引用。

注意
雖然閉包多次使用了 self 甥角，它只捕獲 HTMLElement 實例的一個強引用网严。

如果設置 paragraph 變量為 nil ，打破它持有的 HTMLElement 實例的強引用蜈膨， HTMLElement 實例和它的閉包都不會被銷毀屿笼，也是因為循環(huán)強引用:

paragraph = nil

注意， HTMLElement 的析構函數中的消息并沒有被打印翁巍，證明了 HTMLElement 實例并沒有被銷毀。

解決閉包引起的循環(huán)強引用

在定義閉包時同時定義捕獲列表作為閉包的一部分休雌，通過這種方式可以解決閉包和類實例之間的循環(huán)強引用灶壶。捕獲列表定義了閉包體內捕獲一個或者多個引用類型的規(guī)則。跟解決兩個類實例間的循環(huán)強引用一樣杈曲，聲明每個捕獲的引用為弱引用或無主引用驰凛，而不是強引用。應當根據代碼關系來決定使用弱引用還是無主引用担扑。

注意
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 someClosure: Void -> String = {
    [unowned self, weak delegate = self.delegate!] in 
    // 這里是閉包的函數體
} 

弱引用和無主引用

在閉包和捕獲的實例總是互相引用并且總是同時銷毀時烙常，將閉包內的捕獲定義為 無主引用 。

相反的鹤盒，在被捕獲的引用可能會變?yōu)?nil 時蚕脏，將閉包內的捕獲定義為 弱引用 。弱引用總是可選類型侦锯，并且當引用的實例被銷毀后驼鞭，弱引用的值會自動置為 nil 。這使我們可以在閉包體內檢查它們是否存在率触。

注意
如果被捕獲的引用絕對不會變?yōu)?nil 终议，應該用無主引用，而不是弱引用葱蝗。

前面的 HTMLElement 例子中穴张，無主引用是正確的解決循環(huán)強引用的方法。這樣編寫 HTMLElement 類來避免循環(huán)強引用:

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")
     }
}

上面的 HTMLElement 實現和之前的實現一致两曼，除了在 asHTML 閉包中多了一個捕獲列表皂甘。這里，捕獲列表是 [unowned self] 悼凑，表示“將 self 捕獲為無主引用而不是強引用”偿枕。

和之前一樣，我們可以創(chuàng)建并打印 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”