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