官方文档
Swift使用自动引用计数(ARC)机制来追踪和管理你的app的内存。在大多数情况,这意味着Swift的内存管理机制会一直起作用,你不需要自己考虑内存管理。当不再需要类的实例时,ARC会自动释放类所占用的内存。
然而,在少数情况下,ARC为了能帮助你管理内存,需要更多的关于你的代码之间关系的信息。本章描述了这些情况,以及向你展示如何启用ARC来管理你的app的内存。
注意
引用计数只应用于类的实例。结构体和枚举是值类型,不是引用类型,没有通过引用的方式存储和传递。
ARC的工作机制
每次你创建一个类的实例,ARC会分配一大块内存来存储实例的信息。这些内存中保留有实例类型的信息,以及该实例所有存储属性的值信息。
此外,当实例不需要时,ARC会释放该实例所占用的内存,释放的内存用于其他用途。这确保类实例当它不在需要时,不会一直占用内存。
然而,如果ARC释放了正在使用的实例内存,那么它将不会访问实例的属性,或者调用实例的方法。确实,如果你试图访问该实例,你的app很可能会崩溃。
为了确保使用中的实例不会消失,ARC会跟踪和计算当前实例被多少属性,常量和变量所引用。只要存在对该类实例的引用,ARC将不会释放该实例。
为了使这些成为可能,无论你将实例分配给属性,常量或变量,它们都会创建该实例的强引用。之所以称之为“强(strong
)”引用,是因为它会将实例保持住,只要强引用还在,实例是不允许被销毁的。
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
类有一个初始化器,它设置了实例的name
属性并且输出一条信息表明初始化器生效。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"
类实例之间的循环强引用
在上面的例子中,ARC能够追踪你所创建的Person
实例的引用数量,并且会在Person
实例不在使用时销毁。
然而,永远不要写出类实例强引用为0
的代码。如果两个类实例彼此持有一个强引用,因而每个实例都让对方一直存在,就可能发生这种情况。这就是所谓的循环强引用。
解决循环强引用问题,可以通过定义类之间的关系为弱(weak
)引用或无主(unknown
)引用来代替强引用。这个过程在解决类实例之间的循环强引用中有描述。然而,在你学习时如何解决循环强引用问题,就很有必要了解它是如何产生的。
下面的例子展示了一个如何错误创建一个循环强引用。这个例子定义了两个类,分别是Person
和Apartment
,用来建模公寓和它其中的居民:
class Person {
let name: String
init(name: String) {
self.name = name
}
var apartment: Apartment?
deinit {
print("\(name) is being 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
实例有一个叫number
,类型为Int
的属性,并有一个可选的初始化为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
实例之间的强引用关系保留了下来并且不会被断开。
解决实例之间的循环强引用
Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题:弱引用(weak reference
)和无主引用(unowned reference
)。
弱引用和无主引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。
对于生命周期中会变为nil
的实例使用弱引用。相反地,对于初始化赋值后再也不会被赋值为nil
的实例,使用无主引用。
若引用
弱引用不会对其引用的实例保持强引用,因而不会阻止 ARC 销毁被引用的实例。这个特性阻止了引用变为循环强引用。声明属性或者变量时,在前面加上weak
关键字表明这是一个弱引用。
在实例的生命周期中,当引用可能没有值的时候,可以使用弱引用来避免循环引用。如果引用始终有值,则可以使用无主引用来代替。在无主引用中描述。上面的Apartment
例子中,在它的声明周期中,有时是”没有居民”的,因此适合使用弱引用来解决循环强引用。
注意
若引用必须被声明为变量,表明其值能在运行时被修改。若引用不能声明为常量。
因为若引用允许”没有值”,你必须声明每个若引用为一个可选类型。在 Swift 中,推荐使用可选类型描述可能没有值的类型。
因为若引用不会保持引用的实例,即使弱引用存在,实例也可能被销毁。因此,当引用的实例销毁的时候,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
// prints "John Appleseed is being deinitialized"
唯一剩下的指向Apartment
实例的强引用来自于变量unit4A
。如果你断开这个强引用,再也没有指向Apartment
实例的强引用了:
由于再也没有指向Apartment
实例的强引用,该实例也会被销毁:
unit4A = nil
// prints "Apartment 4A is being deinitialized"
无主引用
和弱引用类似,无主引用不会牢牢保持住引用的实例。但是不像若引用,无主引用是永远有值的。因为无主引用总是被定义为非可选类型(non-optional type
)。你可以在声明属性或者变量时,在前面加上关键字unowned
表示这是一个无主引用。
由于无主引用是非可选类型,你不需要在使用它的时候将它展开。无主引用总是可以被直接访问。不过 ARC 无法在实例被销毁后将无主引用设为nil
,因为非可选类型的变量不允许被赋值为nil
。
注意
如果你试图在实例的被销毁后访问无主引用,那么你将触发运行时错误。当你确保引用会一直引用一个实例的时候,在使用无主引用。
还要注意的是,如果你试图访问实例已经被销毁的无主引用,Swift 确保程序会直接崩溃,而不会发生无法预期的行为。所以你应当避免这样的事情发生。
下面的例子定义了两个类,Customer
和CreditCard
,模拟了银行客户和客户的信用卡。这两个类中,每一个都将另外一个类的实例作为自身的属性。这种关系可能会造成循环强引用。
Customer
和CreditCard
之间的关系与前面弱引用例子中Apartment
和Person
的关系略微不同。在这个数据模型中,一个客户可能有或者没有信用卡,但是一张信用卡总是关联着一个客户。为了表示这种关系,Customer
类有一个可选类型的card
属性,但是CreditCard
类有一个非可选类型的customer
属性。
由于信用卡总是关联着一个客户,因此将customer
属性定义为无主引用,用以避免循环强引用:
class Customer {
let name: Stirng
var card: CarditCard?
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
实例作为customer
的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
// prints "John Appleseed is being deinitialized"
// prints "Card #1234567890123456 is being deinitialized"
最后的代码展示了在john
变量被设为nil
后Customer
实例和CreditCard
实例的构造函数都打印出了“销毁”的信息。
无主引用和隐式解析可选属性
上面弱引用和无主引用例子涵盖了两种常用的需要打破循环强引用的场景。
Person
和Apartment
的例子展示了两个属性的值都允许为nil
,并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。
Customer
和CreditCard
的例子展示了一个属性的值允许为nil
,而另一个属性的值不允许为nil
,这也可能导致循环强引用。这种场景最好使用无主引用来解决。
然而, 还有第三种场景,在这种场景中,两个属性都必须有值,并且初始化完成后永远不会为nil
。在这种场景中,需要一个类使用无主属性,而另外一个类使用隐式解析可选属性。
一旦初始化完成,这两个属性能被直接访问(不需要可选展开),同时避免了循环引用。这一节将为你展示如何建立这种关系。
下面的例子定义了两个类,Country
和City
,每个类将另外一个类的实例保存为属性。在这个数据模型中,每个国家必须有首都,每个城市必须属于一个国家。为了实现这种关系,Country
类拥有一个capitalCity
属性,而City
类有一个country
属性:
class Country {
let name: String
var capitalCity: City!
init(name: String, capitalName: String) {
self.name = name
self.capitalCity = City(name: capitalName, country: self)
}
}
class City {
let name: String
unowned let country: Country
init(name: Stirng, 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)")
// prints "Canada's capital city is called Ottawa"
在上面的例子中,使用隐式解析可选值的意义在于满足了两个类构造函数的需求。capitalCity
属性在初始化完成后,能像非可选值一样使用和存取同时还避免了循环强引用。
闭包引起的循环强引用
上面我们看到了荀晗强引用是在两个实例属性互相保持对方的强音哟过时产生的,还知道了如何用弱引用和无主引用来打破这些循环强引用。
循环强引用还会出现在当你把一个闭包分配给类实例的属性的时候,并且这个闭包中又使用了这个实例。这个闭包体中可能访问了实例的某个属性,例如self.someProperty
,或者这个闭包调用了一个实例的方法,例如self.someMethod()
。这两种情况都导致了闭包 “捕获” self
,从而产生了循环强引用。
循环强引用的产生,是因为闭包和类相似,都是引用类型。当你把闭包分配给了一个属性,你也把一个引用分配给了这个闭包。实质上,这跟之前上面的问题是一样的–两个强引用让彼此一直有效。然而,和两个类实例不同,这次一个是类实例,另一个是闭包。
Swift 提供了一种优雅的方法来解决这个问题,称之为闭包捕获列表(closuer capture list
)。但是,在学习如何用闭包捕获列表破坏循环强引用之前,先来了解一下这里的循环强引用是如何产生的,这对我们很有帮助。
下面的例子为你展示了当一个闭包引用了self
后是如何产生一个循环强引用的。例子中定义了一个叫HTMLElement
的类,用一种简单的模型表示 HTML 中的一个单独的元素:
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: Void -> String = {
if var asNTML = 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
类定义了一个name
属性来表示这个元素的名称,例如代表段落的”p
“,或者代表换行的”br
“。HTMLElement
还定义了一个可选属性text
,用来设置和展现 HTML
元素的文本。
除了上面的两个属性,HTMLElement
还定义了一个lazy
属性asHTML
。这个属性引用了一个将name
和text
组合成 HTML
字符串片段的闭包。该属性是Void -> String
类型,或者可以理解为“一个没有参数,返回String
的函数”。
默认情况下,闭包赋值给了asHTML
属性,这个闭包返回一个代表HTML
标签的字符串。如果text
值存在,该标签就包含可选值text
;如果text
不存在,该标签就不包含文本。对于段落元素,根据text
是”some text
“还是nil
,闭包会返回”<p>some text</p>
“或者”<p />
“。
可以像实例方法那样去命名、使用asHTML
属性。然而,由于asHTML
是闭包而不是实例方法,如果你想改变特定元素的HTML
处理的话,可以用自定义的闭包来取代默认值。
注意:
asHTML
声明为lazy
属性,因为只有当元素确实需要处理为HTML
输出的字符串时,才需要使用asHTML
。也就是说,在默认的闭包中可以使用self
,因为只有当初始化完成以及self
确实存在后,才能访问lazy
属性。
HTMLElement
类只提供一个构造函数,通过name
和text
(如果有的话)参数来初始化一个元素。该类也定义了一个析构函数,当HTMLElement
实例被销毁时,打印一条消息。
下面的代码展示了如何用HTMLElement
类创建实例并打印消息。
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// prints"hello, world"
注意:
上面的paragraph
变量定义为可选HTMLElement
,因此我们可以赋值nil给它来演示循环强引用。
不幸的是,上面写的HTMLElement
类产生了类实例和asHTML
默认值的闭包之间的循环强引用。循环强引用如下图所示:
实例的asHTML
属性持有闭包的强引用。但是,闭包在其闭包体内使用了self
(引用了self.name
和self.text
),因此闭包捕获了self
,这意味着闭包又反过来持有了HTMLElement
实例的强引用。这样两个对象就产生了循环强引用。(更多关于闭包捕获值的信息,请参考值捕获)。
注意:
虽然闭包多次使用了self
,它只捕获HTMLElement
实例的一个强引用。
如果设置paragraph
变量为nil
,打破它持有的HTMLElement
实例的强引用,HTMLElement
实例和它的闭包都不会被销毁,也是因为循环强引用:
paragraph = nil
注意HTMLElementdeinitializer
中的消息并没有被打印,证明了HTMLElement
实例并没有被销毁。
解决闭包引起的循环强引用
你可以通过定义捕获列表作为闭包的定义来解决在闭包和类实例之间的循环强引用。捕获列表定义了当在闭包体里捕获一个或多个引用类型的规则。正如在两个类实例之间的循环强引用,声明每个捕获的引用为引用或无主引用而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。
注意
Swift 有如下要求:只要在闭包内使用self
的成员,就要用self.someProperty
或者self.someMethod
(而不只是someProperty
或someMethod
)。这提醒你可能会一不小心就捕获了self
。
定义捕获列表
捕获列表中的每一项都由一对元素组成,一个元素是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: Void -> String = {
[unowned self, weak delegate = self.delegate!] in
// closure body goes here
}
弱引用和无主引用
在闭包和捕获的实例总是互相引用时并且总是同时销毁时,将闭包内的捕获定义为无主引用。
相反,在被捕获的引用可能会变为nil
时,定义一个弱引用的捕获。弱引用总是可选类型,当实例的引用销毁的时候会自动变为nil
。这使我们可以在闭包体内检查它们是否存在。
注意
如果被捕获的引用绝对不会变为nil,应该用无主引用,而不是弱引用。
前面的HTMLElement
例子中,无主引用是正确的解决循环强引用的方法。这样编写HTMLElement
类来避免循环强引用:
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: Void -> 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"
了解更多关于捕获列表,请看捕获列表。