Latest web development tutorials

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: "w3big")


//赋值给其他两个变量,该实例又会多出两个强引用
reference2 = reference1
reference3 = reference1

//断开第一个强引用
reference1 = nil
//断开第二个强引用
reference2 = nil
//断开第三个强引用,并调用析构函数
reference3 = nil

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

w3big 开始初始化
w3big 被析构

類實例之間的循環強引用

在上面的例子中,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) 被析构") }
}

// 两个变量都被初始化为nil
var w3big: Person?
var number73: Apartment?

// 赋值
w3big = Person(name: "w3big")
number73 = Apartment(number: 73)

// 意感叹号是用来展开和访问可选变量 w3big 和 number73 中的实例
// 循环强引用被创建
w3big!.apartment = number73
number73!.tenant = w3big

// 断开 w3big 和 number73 变量所持有的强引用时,引用计数并不会降为 0,实例也不会被 ARC 销毁
// 注意,当你把这两个变量设为nil时,没有任何一个析构函数被调用。
// 强引用循环阻止了Person和Apartment类实例的销毁,并在你的应用程序中造成了内存泄漏
w3big = nil
number73 = 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 = nil
list = 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 被析构