Swift4.2语言规范(二十五) 自动引用计数(ARC)

ARC是如何工作的

每次创建类的新实例时，ARC都会分配一块内存来存储有关该实例的信息。此内存保存有关实例类型的信息，以及与该实例关联的任何存储属性的值。

此外，当不再需要实例时，ARC释放该实例使用的内存，以便可以将内存用于其他目的。这可确保类实例在不再需要时不会占用内存空间。

但是，如果ARC要释放仍在使用的实例，则将无法再访问该实例的属性，或调用该实例的方法。实际上，如果您尝试访问该实例，您的应用很可能会崩溃。

为了确保实例在仍然需要时不会消失，ARC会跟踪当前引用每个类实例的属性，常量和变量的数量。只要至少有一个对该实例的活动引用仍然存在，ARC就不会释放实例。

为了实现这一点，无论何时将类实例分配给属性，常量或变量，该属性，常量或变量都会对实例进行强引用。该引用被称为“强”引用，因为它保持对该实例的坚定持有，并且只要该强引用仍然存在就不允许它被释放。

ARC在行动

以下是自动引用计数如何工作的示例。此示例以一个名为的简单类开头，该类Person定义了一个名为的存储常量属性name：

 1 class Person {
 2     let name: String
 3     init(name: String) {
 4         self.name = name
 5         print("(name) is being initialized")
 6     }
 7     deinit {
 8         print("(name) is being deinitialized")
 9     }
10 }

本Person类有设置实例的一个初始化name属性并显示一条消息，指示初始化正在进行中。所述Person类还具有当类的实例被释放，打印的消息的deinitializer。

下一个代码片段定义了三个类型的变量Person?，这些变量用于Person在后续代码片段中设置对新实例的多个引用。由于这些变量属于可选类型（Person?而不是Person），因此它们会自动使用值初始化nil，并且当前不会引用Person实例。

1 var reference1: Person?
2 var reference2: Person?
3 var reference3: Person?

您现在可以创建一个新Person实例并将其分配给以下三个变量之一：

1 reference1 = Person(name: "John Appleseed")
2 // Prints "John Appleseed is being initialized"

请注意，消息是在您调用类的初始化程序时打印的。这证实已经进行了初始化。"John?Appleseed?is?being?initialized"Person

因为新Person实例已分配给reference1变量，所以现在有一个强引用reference1到新Person实例。因为至少有一个强引用，ARC确保将其Person保留在内存中并且不会被释放。

如果将同一Person实例分配给另外两个变量，则会建立另外两个对该实例的强引用：

1 reference2 = reference1
2 reference3 = reference1

现在有三个对这个单一Person实例的强引用。

如果通过分配nil两个变量来中断其中两个强引用（包括原始引用），Person则会保留单个强引用，并且不会释放实例：

1 reference1 = nil
2 reference2 = nil

ARC不会释放Person实例，直到第三个也是最后一个强引用被破坏，此时很明显您不再使用该Person实例：

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

类实例之间的强引用循环

在上面的示例中，ARC能够跟踪Person您创建的新实例的引用数，并在Person不再需要该实例时取消分配该实例。

但是，可以编写一个代码，其中类的实例永远不会达到零强引用的程度。如果两个类实例彼此具有强引用，则会发生这种情况，这样每个实例都会使另一个实例保持活动状态。这被称为强引用周期。

您可以通过将类之间的某些关系定义为弱引用或无引用而不是强引用来解决强引用循环。在解决类实例之间的强引用循环中描述了此过程。但是，在您学习如何解决强引用循环之前，了解如何引起这样的循环是有用的。

这是一个如何通过意外创建强引用循环的示例。这个例子定义了两个叫做Person和的类Apartment，它们模拟了一套公寓及其居民：

 1 class Person {
 2     let name: String
 3     init(name: String) { self.name = name }
 4     var apartment: Apartment?
 5     deinit { print("(name) is being deinitialized") }
 6 }
 7 
 8 class Apartment {
 9     let unit: String
10     init(unit: String) { self.unit = unit }
11     var tenant: Person?
12     deinit { print("Apartment (unit) is being deinitialized") }
13 }

每个Person实例都有一个nametype属性String和一个apartment最初的可选属性nil。该apartment物业是可选的，因为一个人可能并不总是有公寓。

类似地，每个Apartment实例都具有unit类型的属性，String并且具有tenant最初的可选属性nil。租户属性是可选的，因为公寓可能并不总是有租户。

这两个类还定义了一个deinitializer，它打印出该类的一个实例被取消初始化的事实。这使您可以查看是否按预期释放实例Person和Apartment。

下一个代码片段定义了两个名为john和的可选类型变量unit4A，它们将被设置为下面的特定Apartment和Person实例。nil由于是可选的，这两个变量都具有初始值：

1 var john: Person?
2 var unit4A: Apartment?

您现在可以创建特定的Person实例和Apartment实例，并将这些新实例分配给john和unit4A变量：

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

以下是创建和分配这两个实例后强引用的外观。该john变量现在具有对新Person实例的强引用，并且该unit4A变量具有对新Apartment实例的强引用：

您现在可以将两个实例链接在一起，以便此人拥有公寓，并且公寓有租户。注意，感叹号（!）用于解开和访问存储在内部的情况下，john和unit4A任选的变量，以便这些实例的属性可设置为：

1 john!.apartment = unit4A
2 unit4A!.tenant = john

以下是将两个实例链接在一起后强引用的外观：

不幸的是，链接这两个实例会在它们之间产生强大的引用周期。Person实例现在具有对实例的强引用Apartment，并且Apartment实例具有对实例的强引用Person。因此，当您断开john和unit4A变量所持有的强引用时，引用计数不会降为零，并且ARC不会释放实例：

1 john = nil
2 unit4A = nil

请注意，将这两个变量设置为时，都不会调用deinitializer?nil。强引用循环可防止Person和Apartment实例被释放，从而导致应用程序内存泄漏。

以下是在将john和unit4A变量设置为以下后强引用的外观nil：

Person实例和Apartment实例之间的强引用仍然存在且无法被破坏。

解决类实例之间的强引用循环

当您使用类类型的属性时，Swift提供了两种解决强引用循环的方法：弱引用和无引用引用。

弱引用和无引用引用使引用周期中的一个实例能够引用另一个实例而不保持强大的保持。然后，实例可以相互引用而不会创建强大的引用周期。

当另一个实例的生命周期更短时，即在可以首先释放另一个实例时，使用弱引用。在Apartment上面的示例中，公寓在其生命周期中的某个点上没有租户是合适的，因此弱引用是在这种情况下打破引用周期的适当方式。相反，当另一个实例具有相同的生命周期或更长的生命周期时，请使用无主引用。

 1 class Person {
 2     let name: String
 3     init(name: String) { self.name = name }
 4     var apartment: Apartment?
 5     deinit { print("(name) is being deinitialized") }
 6 }
 7 
 8 class Apartment {
 9     let unit: String
10     init(unit: String) { self.unit = unit }
11     weak var tenant: Person?
12     deinit { print("Apartment (unit) is being deinitialized") }
13 }

1 var john: Person?
2 var unit4A: Apartment?
3 
4 john = Person(name: "John Appleseed")
5 unit4A = Apartment(unit: "4A")
6 
7 john!.apartment = unit4A
8 unit4A!.tenant = john

1 john = nil
2 // Prints "John Appleseed is being deinitialized"

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

 1 class Customer {
 2     let name: String
 3     var card: CreditCard?
 4     init(name: String) {
 5         self.name = name
 6     }
 7     deinit { print("(name) is being deinitialized") }
 8 }
 9 
10 class CreditCard {
11     let number: UInt64
12     unowned let customer: Customer
13     init(number: UInt64,customer: Customer) {
14         self.number = number
15         self.customer = customer
16     }
17     deinit { print("Card #(number) is being deinitialized") }
18 }

1 var john: Customer?

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

1 john = nil
2 // Prints "John Appleseed is being deinitialized"
3 // Prints "Card #1234567890123456 is being deinitialized"

 1 class Country {
 2     let name: String
 3     var capitalCity: City!
 4     init(name: String,capitalName: String) {
 5         self.name = name
 6         self.capitalCity = City(name: capitalName,country: self)
 7     }
 8 }
 9 
10 class City {
11     let name: String
12     unowned let country: Country
13     init(name: String,country: Country) {
14         self.name = name
15         self.country = country
16     }
17 }

1 var country = Country(name: "Canada",capitalName: "Ottawa")
2 print("(country.name)‘s capital city is called (country.capitalCity.name)")
3 // Prints "Canada‘s capital city is called Ottawa"

闭包的强引用周期

您在上面看到了当两个类实例属性相互之间具有强引用时，如何创建强引用循环。您还了解了如何使用弱和无主引用来打破这些强大的引用周期。

如果将闭包分配给类实例的属性，并且该闭包的主体捕获实例，则也会发生强引用循环。这种捕获可能是因为闭包的主体访问实例的属性，例如self.someProperty，或者因为闭包调用实例上的方法，例如self.someMethod()。在任何一种情况下，这些访问都会导致闭包“捕获”?self，从而创建一个强大的引用周期。

这种强引用循环的发生是因为闭包（如类）是引用类型。为属性分配闭包时，您将分配对该闭包的引用。实质上，它与上面的问题相同 - 两个强引用相互保持活着。但是，这次是一个类实例和一个闭包，而不是两个类实例。

Swift为这个问题提供了一个优雅的解决方案，称为闭包捕获列表。但是，在学习如何使用闭包捕获列表打破强引用循环之前，了解如何引起这样的循环是有用的。

下面的示例显示了在使用引用的闭包时如何创建强引用循环self。此示例定义了一个名为的类HTMLElement，它为HTML文档中的单个元素提供了一个简单模型：

 1 class HTMLElement {
 2 
 3     let name: String
 4     let text: String?
 5 
 6     lazy var asHTML: () -> String = {
 7         if let text = self.text {
 8             return "<(self.name)>(text)</(self.name)>"
 9         } else {
10             return "<(self.name) />"
11         }
12     }
13 
14     init(name: String,text: String? = nil) {
15         self.name = name
16         self.text = text
17     }
18 
19     deinit {
20         print("(name) is being deinitialized")
21     }
22 
23 }

的HTMLElement类定义了一个name属性，该属性指示该元素的名称，诸如"h1"用于一个标题元素，"p"为段落元件，或"br"用于换行元件。HTMLElement还定义了一个可选text属性，您可以将其设置为表示要在该HTML元素中呈现的文本的字符串。

除了这两个简单属性之外，HTMLElement该类还定义了一个名为的惰性属性asHTML。此属性引用，结合了封闭name和text成HTML字符串片段。所述asHTML属性的类型的，或“不带参数，并返回一个函数值”。()?->?StringString

默认情况下，为asHTML属性分配一个闭包，该闭包返回HTML标记的字符串表示形式。此标记包含可选text值（如果存在），或者不包含文本内容（如果text不存在）。对于段落元素，闭包将返回或取决于属性是否等于或。"<p>some?text</p>""<p?/>"text"some?text"nil

该asHTML属性的命名和使用方式有点像实例方法。但是，因为asHTML是闭包属性而不是实例方法，所以asHTML如果要更改特定HTML元素的HTML呈现，则可以使用自定义闭包替换属性的默认值。

例如，asHTML属性可以设置为封闭默认为一些文字，如果text属性nil，以防止返回一个空的HTML标签表示：

1 let heading = HTMLElement(name: "h1")
2 let defaultText = "some default text"
3 heading.asHTML = {
4     return "<(heading.name)>(heading.text ?? defaultText)</(heading.name)>"
5 }
6 print(heading.asHTML())
7 // Prints "<h1>some default text</h1>"

的HTMLElement类提供了一个单一的初始值设定，这需要一个name参数，并（如果需要的话）一个text参数来初始化新的元件。该类还定义了一个deinitializer，它打印一条消息以显示HTMLElement实例何时被释放。

以下是使用HTMLElement该类创建和打印新实例的方法：

1 var paragraph: HTMLElement? = HTMLElement(name: "p",text: "hello,world")
2 print(paragraph!.asHTML())
3 // Prints "<p>hello,world</p>"

不幸的是，HTMLElement如上所述，该类在HTMLElement实例和用于其默认asHTML值的闭包之间创建了一个强引用循环。这是循环的样子：

实例的asHTML属性强烈引用它的闭包。然而，因为封闭件是指self它的主体内（作为一种方式来引用self.name和self.text），封闭捕获自，这意味着它保持很强的引用回HTMLElement实例。在两者之间创建了强大的引用周期。（有关在闭包中捕获值的更多信息，请参阅捕获值。）

如果将paragraph变量设置为nil并断开其对HTMLElement实例的强引用，则实例HTMLElement及其闭包都不会被释放，因为强引用周期：

paragraph = nil

请注意，HTMLElement不会打印deinitializer?中的消息，这表示HTMLElement实例未取消分配。

解决闭包的强引用周期

通过将捕获列表定义为闭包定义的一部分，可以解决闭包和类实例之间的强引用循环。捕获列表定义在闭包体内捕获一个或多个引用类型时要使用的规则。与两个类实例之间的强引用循环一样，您将每个捕获的引用声明为弱引用或无主引用，而不是强引用。弱或无主的适当选择取决于代码的不同部分之间的关??系。

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

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

 1 class HTMLElement {
 2 
 3     let name: String
 4     let text: String?
 5 
 6     lazy var asHTML: () -> String = {
 7         [unowned self] in
 8         if let text = self.text {
 9             return "<(self.name)>(text)</(self.name)>"
10         } else {
11             return "<(self.name) />"
12         }
13     }
14 
15     init(name: String,text: String? = nil) {
16         self.name = name
17         self.text = text
18     }
19 
20     deinit {
21         print("(name) is being deinitialized")
22     }
23 
24 }

1 var paragraph: HTMLElement? = HTMLElement(name: "p",world</p>"

1 paragraph = nil
2 // Prints "p is being deinitialized"