當你每次創建一個類的新的實例的時候，ARC 會分配一塊內存來儲存該實例信息。內存中會包含實例的類型信息，以及這個實例所有相關的存儲型屬性的值。

此外，當實例不再被使用時，ARC 釋放實例所占用的內存，并讓釋放的內存能挪作他用。這確保了不再被使用的實例，不會一直占用內存空間。

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

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

為了使上述成為可能，無論你將實例賦值給屬性、常量或變量，它們都會創建此實例的強引用。之所以稱之為“強”引用，是因為它會將實例牢牢地保持住，只要強引用還在，實例是不允許被銷毀的。

1.自動引用計數實踐

下面的例子展示了自動引用計數的工作機制。例子以一個簡單的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屬性賦值，并打印一條消息以表明初始化過程生效。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 會保證Person實例被保持在內存中不被銷毀。

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

reference2 = reference1
reference3 = reference1

“現在這一個Person實例已經有三個強引用了。
如果你通過給其中兩個變量賦值nil的方式斷開兩個強引用（包括最先的那個強引用），只留下一個強引用，Person實例不會被銷毀：”

reference1 = nil
reference2 = nil

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

reference3 = nil
// Prints "John Appleseed is being deinitialized"

2.類實例之間的循環強引用

“在上面的例子中，ARC 會跟蹤你所新創建的Person實例的引用數量，并且會在Person實例不再被需要時銷毀它。

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

你可以通過定義類之間的關系為弱引用或無主引用，以替代強引用，從而解決循環強引用的問題。具體的過程在解決類實例之間的循環強引用中有描述。不管怎樣，在你學習怎樣解決循環強引用之前，很有必要了解一下它是怎樣產生的。

下面展示了一個不經意產生循環強引用的例子。例子定義了兩個類：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，這正是可選類型的優點：

“var john: Person?
var unit4A: Apartment?

現在你可以創建特定的Person和Apartment實例并將賦值給john和unit4A變量：
john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")”

“在兩個實例被創建和賦值后，下圖表現了強引用的關系。變量john現在有一個指向Person實例的強引用，而變量unit4A有一個指向Apartment實例的強引用：

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

“john!.apartment = unit4A
unit4A!.tenant = john
在將兩個實例聯系在一起之后，強引用的關系如圖所示：”

“不幸的是，這兩個實例關聯后會產生一個循環強引用。Person實例現在有了一個指向Apartment實例的強引用，而Apartment實例也有了一個指向Person實例的強引用。因此，當你斷開john和unit4A變量所持有的強引用時，引用計數并不會降為0，實例也不會被 ARC 銷毀：”

“john = nil
unit4A = nil”

“注意，當你把這兩個變量設為nil時，沒有任何一個析構函數被調用。循環強引用會一直阻止Person和Apartment類實例的銷毀，這就在你的應用程序中造成了內存泄漏。
在你將john和unit4A賦值為nil后，強引用關系如下圖：”

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

3.解決實例之間的循環強引用

“Swift 提供了兩種辦法用來解決你在使用類的屬性時所遇到的循環強引用問題：弱引用（weak reference）和無主引用（unowned reference）。

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

當其他的實例有更短的生命周期時，使用弱引用，也就是說，當其他實例析構在先時。在上面公寓的例子中，很顯然一個公寓在它的生命周期內會在某個時間段沒有它的主人，所以一個弱引用就加在公寓類里面，避免循環引用。相比之下，當其他實例有相同的或者更長生命周期時，請使用無主引用。”

弱引用

弱引用不會對其引用的實例保持強引用，因而不會阻止 ARC 銷毀被引用的實例。這個特性阻止了引用變為循環強引用。聲明屬性或者變量時，在前面加上weak關鍵字表明這是一個弱引用。

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

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

“注意
當 ARC 設置弱引用為nil時，屬性觀察不會被觸發。”

下面的例子跟上面Person和Apartment的例子一致，但是有一個重要的區別。這一次，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）之間的強引用，并關聯兩個實例：

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實例的強引用了：

unit4A = nil
// Prints "Apartment 4A is being deinitialized

“由于再也沒有指向Apartment實例的強引用，該實例也會被銷毀：

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

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

無主引用

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

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

“重要
使用無主引用，你必須確保引用始終指向一個未銷毀的實例。
如果你試圖在實例被銷毀后，訪問該實例的無主引用，會觸發運行時錯誤。”

下面的例子定義了兩個類，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") }
}

注意
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實例的構造函數都打印出了“銷毀”的信息。

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

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

上面弱引用和無主引用的例子涵蓋了兩種常用的需要打破循環強引用的場景。
Person和Apartment的例子展示了兩個屬性的值都允許為nil，并會潛在的產生循環強引用。這種場景最適合用弱引用來解決。

Customer和CreditCard的例子展示了一個屬性的值允許為nil，而另一個屬性的值不允許為nil，這也可能會產生循環強引用。這種場景最適合通過無主引用來解決。”
“然而，存在著第三種場景，在這種場景中，兩個屬性都必須有值，并且初始化完成后永遠不會為nil。在這種場景中，需要一個類使用無主屬性，而另外一個類使用隱式解析可選屬性。

這使兩個屬性在初始化完成后能被直接訪問（不需要可選展開），同時避免了循環引用。這一節將為你展示如何建立這種關系。

下面的例子定義了兩個類，Country和City，每個類將另外一個類的實例保存為屬性。在這個模型中，每個國家必須有首都，每個城市必須屬于一個國家。為了實現這種關系，Country類擁有一個capitalCity屬性，而City類有一個country屬性：

class Country: NSObject {
    
    var name: String?
    var capitalCity: City！
    
    override init() {
        super.init()
    }
  
    init(name: String, capitalName: String) {
        super.init()
        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的構造函數。

以上的意義在于你可以通過一條語句同時創建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屬性在初始化完成后，能像非可選值一樣使用和存取，同時還避免了循環強引用。”