Swift学习笔记(八)-自动引用计数、弱引用和无主引用

Swift 使用自动引用计数(ARC)机制来追踪和管理你的 App 的内存。在大多数情况下，这意味着 Swift的内存管理机制会一直起作用，你不需要自己考虑内存管理。当这些实例不再需要时，ARC会自动释放类实例所占用的内存。 在Swift中使用 ARC 在 Objective-C 中使用 ARC 十分相似。

类实例才拥有引用计数，结构体和枚举这种值类型不是引用类型，没有引用计数。

ARC的工作机制

每次你创建一个类的实例，ARC 会分配一大块内存来存储这个实例的信息。这些内存中保留有实例的类型信息，以及该实例所有存储属性值的信息。 此外，当实例不需要时，ARC 会释放该实例所占用的内存，释放的内存用于其他用途。这确保类实例当它不在需要时，不会一直占用内存。 然而，如果 ARC 释放了正在使用的实例内存，那么它将不会访问实例的属性，或者调用实例的方法。确实，如果你试图访问该实例，你的app很可能会崩溃。 为了确保使用中的实例不会消失，ARC 会跟踪和计算当前实例被多少属性，常量和变量所引用。只要存在对该类实例的引用，ARC 将不会释放该实例。 为了使这些成为可能，无论你将实例分配给属性，常量或变量，它们都会创建该实例的强引用。之所以称之为“强”引用，是因为它会将实例保持住，只要强引用还在，实例是不允许被销毁的。

ARC

下面的例子展示了自动引用计数的工作机制。这个例子由一个简单的 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 类定义了一个初始化器和反初始化器用来打印信息。

下面的代码片段定义了三个 Peroson? 类型的变量，用来按照代码中的顺序，为新的 Person 实例设置多个引用。由于可选类型的变量会被自动初始化为一个 nil 值， 目前还不会引用到 Person 类的实例意思是这样定义不会产生引用计数 。

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

你可以创建一个新的 Person 实例并且将它赋值给其中一个变量：

reference1 = Person(name: “John Appleseed”)
*// prints “John Appleseed is being initialized”*

注意，当调用 person 类的初始化器时，会输出 “John Appleseed is being initialized” 信息。这就说明初始化执行了。

因为 Person 实例已经赋值给了 reference1 变量，现在就有了一个从 reference1 到该实例的强引用。因为至少有一个强引用，ARC可以确保 Person 一直保持在内存中不被销毁。

如果你将同一个 Person 实例分配给了两个变量，则该实例又会多出两个强引用：

reference2 = reference1
reference3 = reference1

现在这一个 Person 实例就有了三个强引用。

如果你通过给其中两个变量赋值 nil 的方式断开两个强引用，只留下一个强引用， Person 实例不会被销毁：

reference1 = nil
reference2 = nil

在你清楚地表明不再使用这个 Person实例时，直到第三个也就是最后一个强引用被断开时ARC 会销毁它。

reference3 = nil
*// prints “John Appleseed is being deinitialized”*

类实例之间的循环强引用

这段内容很长，简单总结一下就是： 实例互相持有会产生循环强引用，并且变量置空无法破除这种强引用。 能理解这一点，可以跳过不看下面的内容。

写出某个类永远不会变成零强引用的代码是可能的。

如果两个类实例彼此持有对方的强引用，因而每个实例都让对方一直存在，就会发生这种情况。这就是所谓的循环强引用。

解决循环强引用问题，可以通过定义类之间的关系为弱引用( weak )或无主引用( unowned )来代替强引用。

例子

下面的例子展示了一个如何意外地创建循环强引用的例子。这个例子定义了两个类，分别是 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 的实例是否像预期的那样被释放。

定义变量然后赋值：

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 和 unit4A 变量所持有的强引用时，引用计数并不会降零，实例也不会被 ARC 释放：

John = nil
unit4A = nil

当我们把这两个变量设为 nil 时，没有任何一个反初始化器被调用。循环强引用会一直阻止 Person 和 Apartment 类实例的释放，这就在你的应用程序中造成了内存泄漏。 在我们将 john 和 unit4A 赋值为 nil 后，强引用关系如下图：

Person 和 Apartment 实例之间的强引用关系保留了下来并且不会被断开。

破除实例之间的循环强引用

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

现在，两个关联在一起的实例的引用关系如下图所示：

断开john变量的强引用，Person对象被释放:

John = nil
*// prints “John Appleseed is being deinitialized”*

现在只剩下来自 unit4A 变量对 Apartment 实例的强引用。再打断这个强引用，那么 Apartment实例就再也没有强引用了：

unit4A = nil
*// prints “Apartment 4A is being deinitialized”*

没有指向 Apartment 实例的强引用，该实例得到释放：

总结：当最后一个强引用被破除时，对象将会被释放

无主引用

和弱引用类似，无主引用不会牢牢保持住引用的实例。但是不像弱引用，总之，无主引用假定是永远有值的。因此，无主引用总是被定义为非可选类型。你可以在声明属性或者变量时，在前面加上关键字 unowned 表示这是一个无主引用。

由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以直接访问。不过 ARC 无法在实例被释放后将无主引用设为 nil ，因为非可选类型的变量不允许被赋值为 nil 。

如果你试图访问引用的实例已经被释放了的无主引用，Swift 会确保程序直接崩溃。

例子

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

定义一个可选Customer变量，声明为可选项，所以被初始化为nil

var John: Customer?

初始化一个 Customer 实例，分配一个新的 CreditCard 实例作为 customer的 card 属性：

John = Customer(name: “John Appleseed”)
John!.card = CreditCard(number: 1234_5678_9012_3456， customer: John!)

现在 Customer 实例对 CreditCard 实例有一个强引用，并且 CreditCard 实例对 Customer 实例有一个无主引用。

断开john变量的引用

John = nil
*// prints “John Appleseed is being deinitialized”*
*// prints “Card #1234567890123456 is being deinitialized”*

由于 Customer的无主引用，当你断开john 变量持有的强引用时，那么就再也没有指向 Customer 实例的强引用了，Customer实例会被释放，紧接着CreditCard实例也会被释放。

不安全的无主引用

使用unowned(unsafe)来明确使用了一个不安全无主引用。如果你在实例的引用被释放后访问这个不安全无主引用，你的程序就会尝试访问这个实例曾今存在过的内存地址，这就是不安全操作。

无主可选引用

你可以给类标记可选引用来作为无主引用。从 ARC 所有权模型角度来看，无主可选引用和弱引用可在同一个上下文中使用。区别在于使用无主可选引用时，你需要负责保证它总引用到一个合法对象或 nil。

例子:

unowned var nextCourse: Course?

无主可选引用并不保持它包含的对象的强引用，所以它并不会阻止 ARC 释放实例。它的行为和无主引用在 ARC 下一致，除了无主可选引用能是 nil 。

无主引用和隐式展开的可选属性

var capitalCity: City!

通过在类型结尾处加上感叹号 City! 的方式，以声明 Country 的 capitalCity 属性为一个隐式展开的可选属性。capitalCity 属性有一个默认值 nil，但是不需要展开它的值就能访问它。

你可以通过一条语句同时创建 Country和 City 的实例，而不产生循环强引用，并且 capitalCity 的属性能被直接访问，而不需要通过感叹号来展开它的可选值：

var country = Country(name: “Canada”, capitalName: “Ottawa”)
print(“\(country.name)’s capital city is called \(country.capitalCity.name)”)
*// prints “Canada’s capital city is called Ottawa”*

在上面的例子中，使用隐式展开的可选属性的意义在于满足了两段式初始化器的需求。 capitalCity 属性在初始化完成后，就能像非可选项一样使用和存取，同时还避免了循环强引用。

闭包的循环强引用

闭包和实例之间可能会产生循环强引用。

Swift 提供了一种优雅的方法来解决这个问题，称之为闭包捕获列表（ closuer capture list ）。

例子

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())
*// prints”hello, world”*

闭包在其闭包体内使用了 self （引用了 self.name 和 self.text ），因此闭包捕获了 self ，这意味着闭包又反过来持有了 HTMLElement 实例的强引用。这样两个对象就产生了循环强引用。

如果设置 paragraph 变量为 nil ，不能打破这种循环强引用，闭包和实例都没有被释放：

paragraph = nil

解决闭包的循环强引用

定义捕获列表

捕获列表中的每一项都由 weak 或 unowned 关键字与类实例的引用（如 self ）或初始化过的变量（如 delegate = self.delegate! ）成对组成。这些项写在方括号中用逗号分开。 把捕获列表放在形式参数和返回类型前边，如果它们存在的话：

lazy var someClosure: (Int, String) -> String = {
    [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in
    *// closure body goes here*
}

如果闭包没有指明形式参数列表或者返回类型，是因为它们会通过上下文推断，那么就把捕获列表放在关键字in 前边，闭包最开始的地方：

lazy var someClosure: () -> String = {
    [unowned self, weak delegate = self.delegate!] in
    *// closure body goes here*
}

弱引用和无主引用

如果被捕获的引用永远不会变为 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) is being deinitialized”)
    }
    
}

上面的 HTMLElement 实现和之前的实现一致，除了在 asHTML 闭包中多了一个捕获列表。这里，捕获列表是 [unowned self] ，表示“用无主引用而不是强引用来捕获 self ”。 和之前一样，我们可以创建并打印 HTMLElement 实例：

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

使用捕获列表后引用关系如下图所示： 这次，闭包以无主引用的形式捕获 self ，并不会持有 HTMLElement 实例的强引用。如果将 paragraph 赋值为 nil ， HTMLElement 实例将会被释放，并能看到它的反初始化器打印出的消息。

paragraph = nil
*// prints “p is being deinitialized”*