Swift 自動引用計數（ARC）

Swift 使用自動引用計數（ARC）這一機制來跟蹤和管理應用程序的內存

通常情況下我們不需要去手動釋放內存，因為 ARC 會在類的實例不再被使用時，自動釋放其佔用的內存。

但在有些時候我們還是需要在代碼中實現內存管理。

ARC 功能

• 當每次使用 init() 方法創建一個類的新的實例的時候，ARC 會分配一大塊內存用來儲存實例的信息。

• 內存中會包含實例的類型信息，以及這個實例所有相關屬性的值。

• 當實例不再被使用時，ARC 釋放實例所佔用的內存，並讓釋放的內存能挪作他用。

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

• 實例賦值給屬性、常量或變數，它們都會創建此實例的強引用，只要強引用還在，實例是不允許被銷毀的。

ARC 實例

class Person {
let name: String
init(name: String) {
self.name = name print("(name) 開始初始化")
}
deinit {
print("(name) 被析構")
}}// 值會被自動初始化為nil，目前還不會引用到Person類的實例var reference1: Person?var reference2: Person?var reference3: Person?// 創建Person類的新實例reference1 = Person(name: "Runoob")//賦值給其他兩個變數，該實例又會多出兩個強引用reference2 = reference1
reference3 = reference1//斷開第一個強引用reference1 = nil//斷開第二個強引用reference2 = nil//斷開第三個強引用，並調用析構函數reference3 = nil

以上程序執行輸出結果為：

Runoob 開始初始化Runoob 被析構

類實例之間的循環強引用

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

然而，我們可能會寫出這樣的代碼，一個類永遠不會有0個強引用。這種情況發生在兩個類實例互相保持對方的強引用，並讓對方不被銷毀。這就是所謂的循環強引用。

實例

下面展示了一個不經意產生循環強引用的例子。例子定義了兩個類：Person和Apartment，用來建模公寓和它其中的居民:

class Person {
let name: String
init(name: String) { self.name = name }
var apartment: Apartment?
deinit { print("(name) 被析構") }}class Apartment {
let number: Int
init(number: Int) { self.number = number }
var tenant: Person?
deinit { print("Apartment #(number) 被析構") }}// 兩個變數都被初始化為nilvar runoob: Person?var number73: Apartment?// 賦值runoob = Person(name: "Runoob")number73 = Apartment(number: 73)// 意感嘆號是用來展開和訪問可選變數 runoob 和 number73 中的實例// 循環強引用被創建runoob!.apartment = number73
number73!.tenant = runoob// 斷開 runoob 和 number73 變數所持有的強引用時，引用計數並不會降為 0，實例也不會被 ARC 銷毀// 注意，當你把這兩個變數設為nil時，沒有任何一個析構函數被調用。// 強引用循環阻止了Person和Apartment類實例的銷毀，並在你的應用程序中造成了內存泄漏runoob = nilnumber73 = nil

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

Swift 提供了兩種辦法用來解決你在使用類的屬性時所遇到的循環強引用問題：

• 弱引用

• 無主引用

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

對於生命周期中會變為nil的實例使用弱引用。相反的，對於初始化賦值後再也不會被賦值為nil的實例，使用無主引用。

弱引用實例

class Module {
let name: String
init(name: String) { self.name = name }
var sub: SubModule?
deinit { print("(name) 主模塊") }}class SubModule {
let number: Int
init(number: Int) { self.number = number }
weak var topic: Module?
deinit { print("子模塊 topic 數為 (number)") }}var toc: Module?var list: SubModule?toc = Module(name: "ARC")list = SubModule(number: 4)toc!.sub = list
list!.topic = toc
toc = nillist = nil

以上程序執行輸出結果為：

ARC 主模塊子模塊 topic 數為 4

無主引用實例

class Student {
let name: String
var section: Marks?
init(name: String) {
self.name = name }
deinit { print("(name)") }}class Marks {
let marks: Int
unowned let stname: Student
init(marks: Int, stname: Student) {
self.marks = marks self.stname = stname }
deinit { print("學生的分數為 (marks)") }}var module: Student?module = Student(name: "ARC")module!.section = Marks(marks: 98, stname: module!)module = nil

以上程序執行輸出結果為：

ARC學生的分數為 98

閉包引起的循環強引用

循環強引用還會發生在當你將一個閉包賦值給類實例的某個屬性，並且這個閉包體中又使用了實例。這個閉包體中可能訪問了實例的某個屬性，例如self.someProperty，或者閉包中調用了實例的某個方法，例如self.someMethod。這兩種情況都導致了閉包 "捕獲" self，從而產生了循環強引用。

實例

下面的例子為你展示了當一個閉包引用了self後是如何產生一個循環強引用的。例子中定義了一個叫HTMLElement的類，用一種簡單的模型表示 HTML 中的一個單獨的元素：

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")
}
}// 創建實例並列印信息var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")print(paragraph!.asHTML())

HTMLElement 類產生了類實例和 asHTML 默認值的閉包之間的循環強引用。

實例的 asHTML 屬性持有閉包的強引用。但是，閉包在其閉包體內使用了self（引用了self.name和self.text），因此閉包捕獲了self，這意味著閉包又反過來持有了HTMLElement實例的強引用。這樣兩個對象就產生了循環強引用。

解決閉包引起的循環強引用:在定義閉包時同時定義捕獲列表作為閉包的一部分，通過這種方式可以解決閉包和類實例之間的循環強引用。

弱引用和無主引用

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

相反的，當捕獲引用有時可能會是nil時，將閉包內的捕獲定義為弱引用。

如果捕獲的引用絕對不會置為nil，應該用無主引用，而不是弱引用。

實例

前面的HTMLElement例子中，無主引用是正確的解決循環強引用的方法。這樣編寫HTMLElement類來避免循環強引用：

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) 被析構")
}
}//創建並列印HTMLElement實例var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")print(paragraph!.asHTML())// HTMLElement實例將會被銷毀，並能看到它的析構函數列印出的消息paragraph = nil

以上程序執行輸出結果為：

<p>hello, world</p>p 被析構

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！