自動(dòng)引用計(jì)數(shù)

Swift 使用自動(dòng)引用計(jì)數(shù)（ARC）機(jī)制來(lái)跟蹤和管理你的應(yīng)用程序的內(nèi)存。通常情況下，Swift 內(nèi)存管理機(jī)制會(huì)一直起作用，你無(wú)須自己來(lái)考慮內(nèi)存的管理。ARC 會(huì)在類的實(shí)例不再被使用時(shí)，自動(dòng)釋放其占用的內(nèi)存。

然而在少數(shù)情況下，為了能幫助你管理內(nèi)存，ARC 需要更多的，代碼之間關(guān)系的信息。本章描述了這些情況，并且為你示范怎樣才能使 ARC 來(lái)管理你的應(yīng)用程序的所有內(nèi)存。在 Swift 使用 ARC 與在 Obejctive-C 中使用 ARC 非常類似，具體請(qǐng)參考 過(guò)渡到 ARC 的發(fā)布說(shuō)明。

注意

引用計(jì)數(shù)僅僅應(yīng)用于類的實(shí)例。結(jié)構(gòu)體和枚舉類型是值類型，不是引用類型，也不是通過(guò)引用的方式存儲(chǔ)和傳遞。

自動(dòng)引用計(jì)數(shù)的工作機(jī)制

每當(dāng)你創(chuàng)建一個(gè)新的類實(shí)例時(shí)，ARC 會(huì)分配一塊內(nèi)存來(lái)儲(chǔ)存該實(shí)例的信息。內(nèi)存中會(huì)包含實(shí)例的類型信息，以及這個(gè)實(shí)例所關(guān)聯(lián)的任何存儲(chǔ)屬性的值。

此外，當(dāng)實(shí)例不再被使用時(shí)，ARC 釋放實(shí)例所占用的內(nèi)存，并讓釋放的內(nèi)存能挪作他用。這確保了不再被使用的實(shí)例，不會(huì)一直占用內(nèi)存空間。

然而，當(dāng) ARC 回收并釋放了正在被使用中的實(shí)例后，該實(shí)例的屬性和方法將不能再被訪問(wèn)和調(diào)用。實(shí)際上，如果你試圖訪問(wèn)這個(gè)實(shí)例，你的應(yīng)用程序很可能會(huì)崩潰。

為了確保使用中的實(shí)例不會(huì)被銷毀，ARC 會(huì)跟蹤和計(jì)算每一個(gè)實(shí)例正在被多少屬性，常量和變量所引用。哪怕實(shí)例的引用數(shù)為 1，ARC 都不會(huì)銷毀這個(gè)實(shí)例。

為了使上述成為可能，無(wú)論你將實(shí)例賦值給屬性、常量或變量，它們都會(huì)創(chuàng)建此實(shí)例的強(qiáng)引用。之所以稱之為“強(qiáng)”引用，是因?yàn)樗鼤?huì)將實(shí)例牢牢地保持住，只要強(qiáng)引用還在，實(shí)例是不允許被銷毀的。

自動(dòng)引用計(jì)數(shù)實(shí)踐

下面的例子展示了自動(dòng)引用計(jì)數(shù)的工作機(jī)制。例子以一個(gè)簡(jiǎn)單的 Person 類開(kāi)始，并定義了一個(gè)叫 name 的常量屬性：

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is being initialized")
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

Person 類有一個(gè)構(gòu)造器，此構(gòu)造器給實(shí)例的 name 屬性賦值，并打印一條消息以表明初始化過(guò)程生效。Person 類也擁有一個(gè)析構(gòu)器，這個(gè)析構(gòu)器會(huì)在實(shí)例被銷毀時(shí)打印一條消息。

接下來(lái)的代碼片段定義了三個(gè)類型為 Person? 的變量，按照代碼片段中的順序，為新的 Person 實(shí)例建立多個(gè)引用。由于這些變量是被定義為可選類型（Person?，而不是 Person），它們的值會(huì)被自動(dòng)初始化為 nil，目前還不會(huì)引用到 Person 類的實(shí)例。

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

現(xiàn)在你可以創(chuàng)建 Person 類的新實(shí)例，并且將它賦值給三個(gè)變量中的一個(gè)：

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

應(yīng)當(dāng)注意到當(dāng)你調(diào)用 Person 類的構(gòu)造器的時(shí)候，"John Appleseed is being initialized" 會(huì)被打印出來(lái)。由此可以確定構(gòu)造器被執(zhí)行。

由于 Person 類的新實(shí)例被賦值給了 reference1 變量，所以 reference1 到 Person 類的新實(shí)例之間建立了一個(gè)強(qiáng)引用。正是因?yàn)檫@一個(gè)強(qiáng)引用，ARC 會(huì)保證 Person 實(shí)例被保持在內(nèi)存中不被銷毀。

如果你將同一個(gè) Person 實(shí)例也賦值給其他兩個(gè)變量，該實(shí)例又會(huì)多出兩個(gè)強(qiáng)引用：

reference2 = reference1
reference3 = reference1

現(xiàn)在這一個(gè) Person 實(shí)例已經(jīng)有三個(gè)強(qiáng)引用了。

如果你通過(guò)給其中兩個(gè)變量賦值 nil 的方式斷開(kāi)兩個(gè)強(qiáng)引用（包括最先的那個(gè)強(qiáng)引用），只留下一個(gè)強(qiáng)引用，Person 實(shí)例不會(huì)被銷毀：

reference1 = nil
reference2 = nil

在你清楚地表明不再使用這個(gè) Person 實(shí)例時(shí)，即第三個(gè)也就是最后一個(gè)強(qiáng)引用被斷開(kāi)時(shí)，ARC 會(huì)銷毀它：

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

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

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

然而，我們可能會(huì)寫出一個(gè)類實(shí)例的強(qiáng)引用數(shù)永遠(yuǎn)不能變成 0 的代碼。如果兩個(gè)類實(shí)例互相持有對(duì)方的強(qiáng)引用，因而每個(gè)實(shí)例都讓對(duì)方一直存在，就是這種情況。這就是所謂的循環(huán)強(qiáng)引用。

你可以通過(guò)定義類之間的關(guān)系為弱引用或無(wú)主引用，來(lái)替代強(qiáng)引用，從而解決循環(huán)強(qiáng)引用的問(wèn)題。具體的過(guò)程在 解決類實(shí)例之間的循環(huán)強(qiáng)引用 中有描述。不管怎樣，在你學(xué)習(xí)怎樣解決循環(huán)強(qiáng)引用之前，很有必要了解一下它是怎樣產(chǎn)生的。

下面展示了一個(gè)不經(jīng)意產(chǎn)生循環(huán)強(qiáng)引用的例子。例子定義了兩個(gè)類：Person 和 Apartment，用來(lái)建模公寓和它其中的居民：

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

每一個(gè) Person 實(shí)例有一個(gè)類型為 String，名字為 name 的屬性，并有一個(gè)可選的初始化為 nil 的 apartment 屬性。apartment 屬性是可選的，因?yàn)橐粋€(gè)人并不總是擁有公寓。

類似的，每個(gè) Apartment 實(shí)例有一個(gè)叫 unit，類型為 String 的屬性，并有一個(gè)可選的初始化為 nil 的 tenant 屬性。tenant 屬性是可選的，因?yàn)橐粭澒⒉⒉豢偸怯芯用瘛?/p>

這兩個(gè)類都定義了析構(gòu)器，在類實(shí)例被析構(gòu)的時(shí)候輸出信息。這讓你能夠知曉 Person 和 Apartment 的實(shí)例是否像預(yù)期的那樣被銷毀。

接下來(lái)的代碼片段定義了兩個(gè)可選類型的變量 john 和 unit4A，并分別被設(shè)為下面的 Apartment 和 Person 的實(shí)例。這兩個(gè)變量都被初始化為 nil，這正是可選類型的優(yōu)點(diǎn)：

var john: Person?
var unit4A: Apartment?

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

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

在兩個(gè)實(shí)例被創(chuàng)建和賦值后，下圖表現(xiàn)了強(qiáng)引用的關(guān)系。變量 john 現(xiàn)在有一個(gè)指向 Person 實(shí)例的強(qiáng)引用，而變量 unit4A 有一個(gè)指向 Apartment 實(shí)例的強(qiáng)引用：

現(xiàn)在你能夠?qū)⑦@兩個(gè)實(shí)例關(guān)聯(lián)在一起，這樣人就能有公寓住了，而公寓也有了房客。注意感嘆號(hào)是用來(lái)展開(kāi)和訪問(wèn)可選變量 john 和 unit4A 中的實(shí)例，這樣實(shí)例的屬性才能被賦值：

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

在將兩個(gè)實(shí)例聯(lián)系在一起之后，強(qiáng)引用的關(guān)系如圖所示：

不幸的是，這兩個(gè)實(shí)例關(guān)聯(lián)后會(huì)產(chǎn)生一個(gè)循環(huán)強(qiáng)引用。Person 實(shí)例現(xiàn)在有了一個(gè)指向 Apartment 實(shí)例的強(qiáng)引用，而 Apartment 實(shí)例也有了一個(gè)指向 Person 實(shí)例的強(qiáng)引用。因此，當(dāng)你斷開(kāi) john 和 unit4A 變量所持有的強(qiáng)引用時(shí)，引用計(jì)數(shù)并不會(huì)降為 0，實(shí)例也不會(huì)被 ARC 銷毀：

john = nil
unit4A = nil

注意，當(dāng)你把這兩個(gè)變量設(shè)為 nil 時(shí)，沒(méi)有任何一個(gè)析構(gòu)器被調(diào)用。循環(huán)強(qiáng)引用會(huì)一直阻止 Person 和 Apartment 類實(shí)例的銷毀，這就在你的應(yīng)用程序中造成了內(nèi)存泄漏。

在你將 john 和 unit4A 賦值為 nil 后，強(qiáng)引用關(guān)系如下圖：

Person 和 Apartment 實(shí)例之間的強(qiáng)引用關(guān)系保留了下來(lái)并且不會(huì)被斷開(kāi)。

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

Swift 提供了兩種辦法用來(lái)解決你在使用類的屬性時(shí)所遇到的循環(huán)強(qiáng)引用問(wèn)題：弱引用（weak reference）和無(wú)主引用（unowned reference）。

弱引用和無(wú)主引用允許循環(huán)引用中的一個(gè)實(shí)例引用另一個(gè)實(shí)例而不保持強(qiáng)引用。這樣實(shí)例能夠互相引用而不產(chǎn)生循環(huán)強(qiáng)引用。

當(dāng)其他的實(shí)例有更短的生命周期時(shí)，使用弱引用，也就是說(shuō)，當(dāng)其他實(shí)例析構(gòu)在先時(shí)。在上面公寓的例子中，很顯然一個(gè)公寓在它的生命周期內(nèi)會(huì)在某個(gè)時(shí)間段沒(méi)有它的主人，所以一個(gè)弱引用就加在公寓類里面，避免循環(huán)引用。相比之下，當(dāng)其他實(shí)例有相同的或者更長(zhǎng)生命周期時(shí)，請(qǐng)使用無(wú)主引用。

弱引用

弱引用不會(huì)對(duì)其引用的實(shí)例保持強(qiáng)引用，因而不會(huì)阻止 ARC 銷毀被引用的實(shí)例。這個(gè)特性阻止了引用變?yōu)檠h(huán)強(qiáng)引用。聲明屬性或者變量時(shí)，在前面加上 weak 關(guān)鍵字表明這是一個(gè)弱引用。

因?yàn)槿跻貌粫?huì)保持所引用的實(shí)例，即使引用存在，實(shí)例也有可能被銷毀。因此，ARC 會(huì)在引用的實(shí)例被銷毀后自動(dòng)將其弱引用賦值為 nil。并且因?yàn)槿跻眯枰谶\(yùn)行時(shí)允許被賦值為 nil，所以它們會(huì)被定義為可選類型變量，而不是常量。

你可以像其他可選值一樣，檢查弱引用的值是否存在，這樣可以避免訪問(wèn)已銷毀的實(shí)例的引用。

注意

當(dāng) ARC 設(shè)置弱引用為 nil 時(shí)，屬性觀察不會(huì)被觸發(fā)。

下面的例子跟上面 Person 和 Apartment 的例子一致，但是有一個(gè)重要的區(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") }
}

然后跟之前一樣，建立兩個(gè)變量（john 和 unit4A）之間的強(qiáng)引用，并關(guān)聯(lián)兩個(gè)實(shí)例：

var john: Person?
var unit4A: Apartment?

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

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

現(xiàn)在，兩個(gè)關(guān)聯(lián)在一起的實(shí)例的引用關(guān)系如下圖所示：

Person 實(shí)例依然保持對(duì) Apartment 實(shí)例的強(qiáng)引用，但是 Apartment 實(shí)例只持有對(duì) Person 實(shí)例的弱引用。這意味著當(dāng)你通過(guò)把 john 變量賦值為 nil 而斷開(kāi)其所保持的強(qiáng)引用時(shí)，再也沒(méi)有指向 Person 實(shí)例的強(qiáng)引用了：

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

由于再也沒(méi)有指向 Person 實(shí)例的強(qiáng)引用，該實(shí)例會(huì)被銷毀，且 tenant 屬性會(huì)被賦值為 nil：

唯一剩下的指向 Apartment 實(shí)例的強(qiáng)引用來(lái)自于變量 unit4A。如果你斷開(kāi)這個(gè)強(qiáng)引用，再也沒(méi)有指向 Apartment 實(shí)例的強(qiáng)引用了：

unit4A = nil
// 打印“Apartment 4A is being deinitialized”

由于再也沒(méi)有指向 Person 實(shí)例的強(qiáng)引用，該實(shí)例會(huì)被銷毀：

注意

在使用垃圾收集的系統(tǒng)里，弱指針有時(shí)用來(lái)實(shí)現(xiàn)簡(jiǎn)單的緩沖機(jī)制，因?yàn)闆](méi)有強(qiáng)引用的對(duì)象只會(huì)在內(nèi)存壓力觸發(fā)垃圾收集時(shí)才被銷毀。但是在 ARC 中，一旦值的最后一個(gè)強(qiáng)引用被移除，就會(huì)被立即銷毀，這導(dǎo)致弱引用并不適合上面的用途。

無(wú)主引用

和弱引用類似，無(wú)主引用不會(huì)牢牢保持住引用的實(shí)例。和弱引用不同的是，無(wú)主引用在其他實(shí)例有相同或者更長(zhǎng)的生命周期時(shí)使用。你可以在聲明屬性或者變量時(shí)，在前面加上關(guān)鍵字 unowned 表示這是一個(gè)無(wú)主引用。

無(wú)主引用通常都被期望擁有值。不過(guò) ARC 無(wú)法在實(shí)例被銷毀后將無(wú)主引用設(shè)為 nil，因?yàn)榉强蛇x類型的變量不允許被賦值為 nil。

重點(diǎn)

使用無(wú)主引用，你必須確保引用始終指向一個(gè)未銷毀的實(shí)例。

如果你試圖在實(shí)例被銷毀后，訪問(wèn)該實(shí)例的無(wú)主引用，會(huì)觸發(fā)運(yùn)行時(shí)錯(cuò)誤。

下面的例子定義了兩個(gè)類，Customer 和 CreditCard，模擬了銀行客戶和客戶的信用卡。這兩個(gè)類中，每一個(gè)都將另外一個(gè)類的實(shí)例作為自身的屬性。這種關(guān)系可能會(huì)造成循環(huán)強(qiáng)引用。

Customer 和 CreditCard 之間的關(guān)系與前面弱引用例子中 Apartment 和 Person 的關(guān)系略微不同。在這個(gè)數(shù)據(jù)模型中，一個(gè)客戶可能有或者沒(méi)有信用卡，但是一張信用卡總是關(guān)聯(lián)著一個(gè)客戶。為了表示這種關(guān)系，Customer 類有一個(gè)可選類型的 card 屬性，但是 CreditCard 類有一個(gè)非可選類型的 customer 屬性。

此外，只能通過(guò)將一個(gè) number 值和 customer 實(shí)例傳遞給 CreditCard 構(gòu)造器的方式來(lái)創(chuàng)建 CreditCard 實(shí)例。這樣可以確保當(dāng)創(chuàng)建 CreditCard 實(shí)例時(shí)總是有一個(gè) customer 實(shí)例與之關(guān)聯(lián)。

由于信用卡總是關(guān)聯(lián)著一個(gè)客戶，因此將 customer 屬性定義為無(wú)主引用，用以避免循環(huán)強(qiáng)引用：

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 屬性的存儲(chǔ)量在 32 位和 64 位系統(tǒng)上都能足夠容納 16 位的卡號(hào)。

下面的代碼片段定義了一個(gè)叫 john 的可選類型 Customer 變量，用來(lái)保存某個(gè)特定客戶的引用。由于是可選類型，所以變量被初始化為 nil：

var john: Customer?

現(xiàn)在你可以創(chuàng)建 Customer 類的實(shí)例，用它初始化 CreditCard 實(shí)例，并將新創(chuàng)建的 CreditCard 實(shí)例賦值為客戶的 card 屬性：

john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

在你關(guān)聯(lián)兩個(gè)實(shí)例后，它們的引用關(guān)系如下圖所示：

Customer 實(shí)例持有對(duì) CreditCard 實(shí)例的強(qiáng)引用，而 CreditCard 實(shí)例持有對(duì) Customer 實(shí)例的無(wú)主引用。

由于 customer 的無(wú)主引用，當(dāng)你斷開(kāi) john 變量持有的強(qiáng)引用時(shí)，再也沒(méi)有指向 Customer 實(shí)例的強(qiáng)引用了：

由于再也沒(méi)有指向 Customer 實(shí)例的強(qiáng)引用，該實(shí)例被銷毀了。其后，再也沒(méi)有指向 CreditCard 實(shí)例的強(qiáng)引用，該實(shí)例也隨之被銷毀了：

john = nil
// 打印“John Appleseed is being deinitialized”
// 打印“Card #1234567890123456 is being deinitialized”

最后的代碼展示了在 john 變量被設(shè)為 nil 后 Customer 實(shí)例和 CreditCard 實(shí)例的析構(gòu)器都打印出了“銷毀”的信息。

注意

上面的例子展示了如何使用安全的無(wú)主引用。對(duì)于需要禁用運(yùn)行時(shí)的安全檢查的情況（例如，出于性能方面的原因），Swift 還提供了不安全的無(wú)主引用。與所有不安全的操作一樣，你需要負(fù)責(zé)檢查代碼以確保其安全性。 你可以通過(guò) unowned(unsafe) 來(lái)聲明不安全無(wú)主引用。如果你試圖在實(shí)例被銷毀后，訪問(wèn)該實(shí)例的不安全無(wú)主引用，你的程序會(huì)嘗試訪問(wèn)該實(shí)例之前所在的內(nèi)存地址，這是一個(gè)不安全的操作。

無(wú)主引用和隱式解包可選值屬性

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

Person 和 Apartment 的例子展示了兩個(gè)屬性的值都允許為 nil，并會(huì)潛在的產(chǎn)生循環(huán)強(qiáng)引用。這種場(chǎng)景最適合用弱引用來(lái)解決。

Customer 和 CreditCard 的例子展示了一個(gè)屬性的值允許為 nil，而另一個(gè)屬性的值不允許為 nil，這也可能會(huì)產(chǎn)生循環(huán)強(qiáng)引用。這種場(chǎng)景最適合通過(guò)無(wú)主引用來(lái)解決。

然而，存在著第三種場(chǎng)景，在這種場(chǎng)景中，兩個(gè)屬性都必須有值，并且初始化完成后永遠(yuǎn)不會(huì)為 nil。在這種場(chǎng)景中，需要一個(gè)類使用無(wú)主屬性，而另外一個(gè)類使用隱式解包可選值屬性。

這使兩個(gè)屬性在初始化完成后能被直接訪問(wèn)（不需要可選展開(kāi)），同時(shí)避免了循環(huán)引用。這一節(jié)將為你展示如何建立這種關(guān)系。

下面的例子定義了兩個(gè)類，Country 和 City，每個(gè)類將另外一個(gè)類的實(shí)例保存為屬性。在這個(gè)模型中，每個(gè)國(guó)家必須有首都，每個(gè)城市必須屬于一個(gè)國(guó)家。為了實(shí)現(xiàn)這種關(guān)系，Country 類擁有一個(gè) capitalCity 屬性，而 City 類有一個(gè) 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
    }
}

為了建立兩個(gè)類的依賴關(guān)系，City 的構(gòu)造器接受一個(gè) Country 實(shí)例作為參數(shù)，并且將實(shí)例保存到 country 屬性。

Country 的構(gòu)造器調(diào)用了 City 的構(gòu)造器。然而，只有 Country 的實(shí)例完全初始化后，Country 的構(gòu)造器才能把 self 傳給 City 的構(gòu)造器。在 兩段式構(gòu)造過(guò)程 中有具體描述。

為了滿足這種需求，通過(guò)在類型結(jié)尾處加上感嘆號(hào)（City!）的方式，將 Country 的 capitalCity 屬性聲明為隱式解包可選值類型的屬性。這意味著像其他可選類型一樣，capitalCity 屬性的默認(rèn)值為 nil，但是不需要展開(kāi)它的值就能訪問(wèn)它。在 隱式解包可選值 中有描述。

由于 capitalCity 默認(rèn)值為 nil，一旦 Country 的實(shí)例在構(gòu)造器中給 name 屬性賦值后，整個(gè)初始化過(guò)程就完成了。這意味著一旦 name 屬性被賦值后，Country 的構(gòu)造器就能引用并傳遞隱式的 self。Country 的構(gòu)造器在賦值 capitalCity 時(shí)，就能將 self 作為參數(shù)傳遞給 City 的構(gòu)造器。

上述的意義在于你可以通過(guò)一條語(yǔ)句同時(shí)創(chuàng)建 Country 和 City 的實(shí)例，而不產(chǎn)生循環(huán)強(qiáng)引用，并且 capitalCity 的屬性能被直接訪問(wèn)，而不需要通過(guò)感嘆號(hào)來(lái)展開(kāi)它的可選值：

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”

在上面的例子中，使用隱式解包可選值值意味著滿足了類的構(gòu)造器的兩個(gè)構(gòu)造階段的要求。capitalCity 屬性在初始化完成后，能像非可選值一樣使用和存取，同時(shí)還避免了循環(huán)強(qiáng)引用。

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

前面我們看到了循環(huán)強(qiáng)引用是在兩個(gè)類實(shí)例屬性互相保持對(duì)方的強(qiáng)引用時(shí)產(chǎn)生的，還知道了如何用弱引用和無(wú)主引用來(lái)打破這些循環(huán)強(qiáng)引用。

循環(huán)強(qiáng)引用還會(huì)發(fā)生在當(dāng)你將一個(gè)閉包賦值給類實(shí)例的某個(gè)屬性，并且這個(gè)閉包體中又使用了這個(gè)類實(shí)例時(shí)。這個(gè)閉包體中可能訪問(wèn)了實(shí)例的某個(gè)屬性，例如 self.someProperty，或者閉包中調(diào)用了實(shí)例的某個(gè)方法，例如 self.someMethod()。這兩種情況都導(dǎo)致了閉包“捕獲”self，從而產(chǎn)生了循環(huán)強(qiáng)引用。

循環(huán)強(qiáng)引用的產(chǎn)生，是因?yàn)殚]包和類相似，都是引用類型。當(dāng)你把一個(gè)閉包賦值給某個(gè)屬性時(shí)，你是將這個(gè)閉包的引用賦值給了屬性。實(shí)質(zhì)上，這跟之前的問(wèn)題是一樣的——兩個(gè)強(qiáng)引用讓彼此一直有效。但是，和兩個(gè)類實(shí)例不同，這次一個(gè)是類實(shí)例，另一個(gè)是閉包。

Swift 提供了一種優(yōu)雅的方法來(lái)解決這個(gè)問(wèn)題，稱之為 閉包捕獲列表（closure capture list）。同樣的，在學(xué)習(xí)如何用閉包捕獲列表打破循環(huán)強(qiáng)引用之前，先來(lái)了解一下這里的循環(huán)強(qiáng)引用是如何產(chǎn)生的，這對(duì)我們很有幫助。

下面的例子為你展示了當(dāng)一個(gè)閉包引用了 self 后是如何產(chǎn)生一個(gè)循環(huán)強(qiáng)引用的。例子中定義了一個(gè)叫 HTMLElement 的類，用一種簡(jiǎn)單的模型表示 HTML 文檔中的一個(gè)單獨(dú)的元素：

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

}

HTMLElement 類定義了一個(gè) name 屬性來(lái)表示這個(gè)元素的名稱，例如代表頭部元素的 "h1"，代表段落的 "p"，或者代表?yè)Q行的 "br"。HTMLElement 還定義了一個(gè)可選屬性 text，用來(lái)設(shè)置 HTML 元素呈現(xiàn)的文本。

除了上面的兩個(gè)屬性，HTMLElement 還定義了一個(gè) lazy 屬性 asHTML。這個(gè)屬性引用了一個(gè)將 name 和 text 組合成 HTML 字符串片段的閉包。該屬性是 Void -> String 類型，或者可以理解為“一個(gè)沒(méi)有參數(shù)，返回 String 的函數(shù)”。

默認(rèn)情況下，閉包賦值給了 asHTML 屬性，這個(gè)閉包返回一個(gè)代表 HTML 標(biāo)簽的字符串。如果 text 值存在，該標(biāo)簽就包含可選值 text；如果 text 不存在，該標(biāo)簽就不包含文本。對(duì)于段落元素，根據(jù) text 是 "some text" 還是 nil，閉包會(huì)返回 "<p>some text</p>" 或者 "<p />"。

可以像實(shí)例方法那樣去命名、使用 asHTML 屬性。然而，由于 asHTML 是閉包而不是實(shí)例方法，如果你想改變特定 HTML 元素的處理方式的話，可以用自定義的閉包來(lái)取代默認(rèn)值。

例如，可以將一個(gè)閉包賦值給 asHTML 屬性，這個(gè)閉包能在 text 屬性是 nil 時(shí)使用默認(rèn)文本，這是為了避免返回一個(gè)空的 HTML 標(biāo)簽：

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 屬性，因?yàn)橹挥挟?dāng)元素確實(shí)需要被處理為 HTML 輸出的字符串時(shí)，才需要使用 asHTML。也就是說(shuō)，在默認(rèn)的閉包中可以使用 self，因?yàn)橹挥挟?dāng)初始化完成以及 self 確實(shí)存在后，才能訪問(wèn) lazy 屬性。

HTMLElement 類只提供了一個(gè)構(gòu)造器，通過(guò) name 和 text（如果有的話）參數(shù)來(lái)初始化一個(gè)新元素。該類也定義了一個(gè)析構(gòu)器，當(dāng) HTMLElement 實(shí)例被銷毀時(shí)，打印一條消息。

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

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

注意

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

不幸的是，上面寫的 HTMLElement 類產(chǎn)生了類實(shí)例和作為 asHTML 默認(rèn)值的閉包之間的循環(huán)強(qiáng)引用。循環(huán)強(qiáng)引用如下圖所示：

實(shí)例的 asHTML 屬性持有閉包的強(qiáng)引用。但是，閉包在其閉包體內(nèi)使用了 self（引用了 self.name 和 self.text），因此閉包捕獲了 self，這意味著閉包又反過(guò)來(lái)持有了 HTMLElement 實(shí)例的強(qiáng)引用。這樣兩個(gè)對(duì)象就產(chǎn)生了循環(huán)強(qiáng)引用。（更多關(guān)于閉包捕獲值的信息，請(qǐng)參考 值捕獲）。

注意

雖然閉包多次使用了 self，它只捕獲 HTMLElement 實(shí)例的一個(gè)強(qiáng)引用。

如果設(shè)置 paragraph 變量為 nil，打破它持有的 HTMLElement 實(shí)例的強(qiáng)引用，HTMLElement 實(shí)例和它的閉包都不會(huì)被銷毀，也是因?yàn)檠h(huán)強(qiáng)引用：

paragraph = nil

注意，HTMLElement 的析構(gòu)器中的消息并沒(méi)有被打印，證明了 HTMLElement 實(shí)例并沒(méi)有被銷毀。

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

在定義閉包時(shí)同時(shí)定義捕獲列表作為閉包的一部分，通過(guò)這種方式可以解決閉包和類實(shí)例之間的循環(huán)強(qiáng)引用。捕獲列表定義了閉包體內(nèi)捕獲一個(gè)或者多個(gè)引用類型的規(guī)則。跟解決兩個(gè)類實(shí)例間的循環(huán)強(qiáng)引用一樣，聲明每個(gè)捕獲的引用為弱引用或無(wú)主引用，而不是強(qiáng)引用。應(yīng)當(dāng)根據(jù)代碼關(guān)系來(lái)決定使用弱引用還是無(wú)主引用。

注意

Swift 有如下要求：只要在閉包內(nèi)使用 self 的成員，就要用 self.someProperty 或者 self.someMethod()（而不只是 someProperty 或 someMethod()）。這提醒你可能會(huì)一不小心就捕獲了 self。

定義捕獲列表

捕獲列表中的每一項(xiàng)都由一對(duì)元素組成，一個(gè)元素是 weak 或 unowned 關(guān)鍵字，另一個(gè)元素是類實(shí)例的引用（例如 self）或初始化過(guò)的變量（如 delegate = self.delegate）。這些項(xiàng)在方括號(hào)中用逗號(hào)分開(kāi)。

如果閉包有參數(shù)列表和返回類型，把捕獲列表放在它們前面：

lazy var someClosure = {
    [unowned self, weak delegate = self.delegate]
    (index: Int, stringToProcess: String) -> String in
    // 這里是閉包的函數(shù)體
}

如果閉包沒(méi)有指明參數(shù)列表或者返回類型，它們會(huì)通過(guò)上下文推斷，那么可以把捕獲列表和關(guān)鍵字 in 放在閉包最開(kāi)始的地方：

lazy var someClosure = {
    [unowned self, weak delegate = self.delegate] in
    // 這里是閉包的函數(shù)體
}

弱引用和無(wú)主引用

在閉包和捕獲的實(shí)例總是互相引用并且總是同時(shí)銷毀時(shí)，將閉包內(nèi)的捕獲定義為 無(wú)主引用。

相反的，在被捕獲的引用可能會(huì)變?yōu)?nil 時(shí)，將閉包內(nèi)的捕獲定義為 弱引用。弱引用總是可選類型，并且當(dāng)引用的實(shí)例被銷毀后，弱引用的值會(huì)自動(dòng)置為 nil。這使我們可以在閉包體內(nèi)檢查它們是否存在。

注意

如果被捕獲的引用絕對(duì)不會(huì)變?yōu)?nil，應(yīng)該用無(wú)主引用，而不是弱引用。

前面的 HTMLElement 例子中，無(wú)主引用是正確的解決循環(huán)強(qiáng)引用的方法。這樣編寫 HTMLElement 類來(lái)避免循環(huán)強(qiáng)引用：

class HTMLElement {

    let name: String
    let text: String?

    lazy var asHTML: () -> 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 實(shí)現(xiàn)和之前的實(shí)現(xiàn)一致，除了在 asHTML 閉包中多了一個(gè)捕獲列表。這里，捕獲列表是 [unowned self]，表示“將 self 捕獲為無(wú)主引用而不是強(qiáng)引用”。

和之前一樣，我們可以創(chuàng)建并打印 HTMLElement 實(shí)例：

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

使用捕獲列表后引用關(guān)系如下圖所示：

這一次，閉包以無(wú)主引用的形式捕獲 self，并不會(huì)持有 HTMLElement 實(shí)例的強(qiáng)引用。如果將 paragraph 賦值為 nil，HTMLElement 實(shí)例將會(huì)被銷毀，并能看到它的析構(gòu)器打印出的消息：

paragraph = nil
// 打印“p is being deinitialized”

你可以查看 捕獲列表 章節(jié)，獲取更多關(guān)于捕獲列表的信息。