Swift学习:2.16 自动引用计数
参考Swift 官方教程《The Swift Programming Language》中文版
自动引用计数Swift 使用自动引用计数(ARC)这一机制来跟踪和管理你的应用程序的内存。通常情况下,Swift 的内存管理机制会一直起着作用,你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时,自动释放其占用的内存。 然而,在少数情况下,ARC 为了能帮助你管理内存,需要更多的关于你的代码之间关系的信息。本章描述了这些情况,并且为你示范怎样启用 ARC 来管理你的应用程序的内存。
自动引用计数的工作机制当你每次创建一个类的新的实例的时候,ARC 会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息,以及这个实例所有相关属性的值。此外,当实例不再被使用时,ARC 释放实例所占用的内存,并让释放的内存能挪作他用。这确保了不再被使用的实例,不会一直占用内存空间。 然而,当 ARC 收回和释放了正在被使用中的实例,该实例的属性和方法将不能再被访问和调用。实际上,如果你试图访问这个实例,你的应用程序很可能会崩溃。 为了确保使用中的实例不会被销毁,ARC 会跟踪和计算每一个实例正在被多少属性,常量和变量所引用。哪怕实例的引用数为一,ARC都不会销毁这个实例。 为了使之成为可能,无论你将实例赋值给属性,常量或者是变量,属性,常量或者变量,都会对此实例创建强引用。之所以称之为强引用,是因为它会将实例牢牢的保持住,只要强引用还在,实例是不允许被销毁的。 自动引用计数实践下面的例子展示了自动引用计数的工作机制。例子以一个简单的 class Person {
let name: String
init(name: String) {
self.name = name
println("(name) is being initialized")
}
deinit {
println("(name) is being deinitialized")
}
}
接下来的代码片段定义了三个类型为 var reference1: Person?
var reference2: Person?
var reference3: Person?
现在你可以创建 reference1 = Person(name: "John Appleseed")
// prints "John Appleseed is being initialized”
应当注意到当你调用 由于 如果你将同样的 reference2 = reference1 reference3 = reference1 现在这个 如果你通过给两个变量赋值 reference1 = nil
reference2 = nil
ARC 会在第三个,也即最后一个强引用被断开的时候,销毁 reference3 = nil
// prints "John Appleseed is being deinitialized"
类实例之间的循环强引用在上面的例子中,ARC 会跟踪你所新创建的 然而,我们可能会写出这样的代码,一个类永远不会有0个强引用。这种情况发生在两个类实例互相保持对方的强引用,并让对方不被销毁。这就是所谓的循环强引用。 你可以通过定义类之间的关系为弱引用或者无主引用,以此替代强引用,从而解决循环强引用的问题。具体的过程在解决类实例之间的循环强引用中有描述。不管怎样,在你学习怎样解决循环强引用之前,很有必要了解一下它是怎样产生的。 下面展示了一个不经意产生循环强引用的例子。例子定义了两个类: class Person {
let name: String
init(name: String) { self.name = name }
var apartment: Apartment?
deinit { println("(name) is being deinitialized") }
}
class Apartment {
let number: Int
init(number: Int) { self.number = number }
var tenant: Person?
deinit { println("Apartment #(number) is being deinitialized") }
}
每一个 类似的,每个 这两个类都定义了析构函数,用以在类实例被析构的时候输出信息。这让你能够知晓 接下来的代码片段定义了两个可选类型的变量 var john: Person?
var number73: Apartment?
现在你可以创建特定的 john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)
在两个实例被创建和赋值后,下图表现了强引用的关系。变量 现在你能够将这两个实例关联在一起,这样人就能有公寓住了,而公寓也有了房客。注意感叹号是用来展开和访问可选变量 john!.apartment = number73 number73!.tenant = john 在将两个实例联系在一起之后,强引用的关系如图所示: 不幸的是,将这两个实例关联在一起之后,一个循环强引用被创建了。 john = nil
number73 = nil
注意,当你把这两个变量设为 在你将
解决实例之间的循环强引用Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题:弱引用(weak reference)和无主引用(unowned reference)。 弱引用和无主引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。 对于生命周期中会变为 弱引用弱引用不会牢牢保持住引用的实例,并且不会阻止 ARC 销毁被引用的实例。这种行为阻止了引用变为循环强引用。声明属性或者变量时,在前面加上 在实例的生命周期中,如果某些时候引用没有值,那么弱引用可以阻止循环强引用。如果引用总是有值,则可以使用无主引用,在无主引用中有描述。在上面
因为弱引用可以没有值,你必须将每一个弱引用声明为可选类型。可选类型是在 Swift 语言中推荐的用来表示可能没有值的类型。 因为弱引用不会保持所引用的实例,即使引用存在,实例也有可能被销毁。因此,ARC 会在引用的实例被销毁后自动将其赋值为 下面的例子跟上面 class Person {
let name: String
init(name: String) { self.name = name }
var apartment: Apartment?
deinit { println("(name) is being deinitialized") }
}
class Apartment {
let number: Int
init(number: Int) { self.number = number }
weak var tenant: Person?
deinit { println("Apartment #(number) is being deinitialized") }
}
然后跟之前一样,建立两个变量(john和number73)之间的强引用,并关联两个实例: var john: Person?
var number73: Apartment?
john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)
john!.apartment = number73
number73!.tenant = john
现在,两个关联在一起的实例的引用关系如下图所示:
由于再也没有指向 john = nil
// prints "John Appleseed is being deinitialized"
唯一剩下的指向 由于再也没有指向 number73 = nil
// prints "Apartment #73 is being deinitialized"
上面的两段代码展示了变量 无主引用和弱引用类似,无主引用不会牢牢保持住引用的实例。和弱引用不同的是,无主引用是永远有值的。因此,无主引用总是被定义为非可选类型(non-optional type)。你可以在声明属性或者变量时,在前面加上关键字 由于无主引用是非可选类型,你不需要在使用它的时候将它展开。无主引用总是可以被直接访问。不过 ARC 无法在实例被销毁后将无主引用设为
下面的例子定义了两个类,
此外,只能通过将一个 由于信用卡总是关联着一个客户,因此将 class Customer {
let name: String
var card: CreditCard?
init(name: String) {
self.name = name
}
deinit { println("(name) is being deinitialized") }
}
class CreditCard {
let number: Int
unowned let customer: Customer
init(number: Int,customer: Customer) {
self.number = number
self.customer = customer
}
deinit { println("Card #(number) is being deinitialized") }
}
下面的代码片段定义了一个叫 var john: Customer?
现在你可以创建 john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456,customer: john!)
在你关联两个实例后,它们的引用关系如下图所示:
由于 由于再也没有指向 john = nil
// prints "John Appleseed is being deinitialized"
// prints "Card #1234567890123456 is being deinitialized"
最后的代码展示了在 无主引用以及隐式解析可选属性上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。
然而,存在着第三种场景,在这种场景中,两个属性都必须有值,并且初始化完成后不能为 这使两个属性在初始化完成后能被直接访问(不需要可选展开),同时避免了循环引用。这一节将为你展示如何建立这种关系。 下面的例子定义了两个类, class Country {
let name: String
let 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: String,country: Country) {
self.name = name
self.country = country
}
}
为了建立两个类的依赖关系,
为了满足这种需求,通过在类型结尾处加上感叹号(City!)的方式,将 由于 以上的意义在于你可以通过一条语句同时创建 var country = Country(name: "Canada",capitalName: "Ottawa")
println("(country.name)'s capital city is called (country.capitalCity.name)")
// prints "Canada's capital city is called Ottawa"
在上面的例子中,使用隐式解析可选值的意义在于满足了两个类构造函数的需求。 闭包引起的循环强引用前面我们看到了循环强引用环是在两个类实例属性互相保持对方的强引用时产生的,还知道了如何用弱引用和无主引用来打破循环强引用。 循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性,并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性,例如 循环强引用的产生,是因为闭包和类相似,都是引用类型。当你把一个闭包赋值给某个属性时,你也把一个引用赋值给了这个闭包。实质上,这跟之前的问题是一样的-两个强引用让彼此一直有效。但是,和两个类实例不同,这次一个是类实例,另一个是闭包。 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 {
println("(name) is being deinitialized")
}
}
除了上面的两个属性, 默认情况下,闭包赋值给了 可以像实例方法那样去命名、使用
下面的代码展示了如何用 var paragraph: HTMLElement? = HTMLElement(name: "p",text: "hello,world")
println(paragraph!.asHTML())
// prints"hello,world"
不幸的是,上面写的 实例的
如果设置 paragraph = nil
注意 解决闭包引起的循环强引用在定义闭包时同时定义捕获列表作为闭包的一部分,通过这种方式可以解决闭包和类实例之间的循环强引用。捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样,声明每个捕获的引用为弱引用或无主引用,而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。
定义捕获列表捕获列表中的每个元素都是由 捕获列表放置在闭包参数列表和返回类型之前: lazy var someClosure: (Int,String) -> String = {
[unowned self] (index: Int,stringToProcess: String) -> String in
// closure body goes here
}
如果闭包没有指定参数列表或者返回类型,则可以通过上下文推断,那么可以捕获列表放在闭包开始的地方,跟着是关键字 lazy var someClosure: () -> String = {
[unowned self] in
// closure body goes here
}
弱引用和无主引用当闭包和捕获的实例总是互相引用时并且总是同时销毁时,将闭包内的捕获定义为无主引用。 相反的,当捕获引用有时可能会是
前面的 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 {
println("(name) is being deinitialized")
}
}
上面的 和之前一样,我们可以创建并打印 var paragraph: HTMLElement? = HTMLElement(name: "p",world")
println(paragraph!.asHTML())
// prints "<p>hello,world</p>"
使用捕获列表后引用关系如下图所示: 这一次,闭包以无主引用的形式捕获 paragraph = nil
// prints "p is being deinitialized" (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |