swift_025（Swift 的自动引用计数(ARC)

//***********swift学习之25--自动引用计数（ARC）--***************************

// 有了手动管理的概念的话，对于开发避免出现一些不易观察的问题，和理解属性引用与实例释放有着重要作用。Swift 使用自动引用计数（ARC）通常情况下我们不需要去手动释放内存，因为 ARC 会在类的实例不再被使用时，自动释放其占用的内存。

ARC 功能

a:当每次使用 init() 方法创建一个类的新的实例的时候，ARC 会分配一大块内存用来储存实例的信息。

b:内存中会包含实例的类型信息，以及这个实例所有相关属性的值。

c:当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。

d:为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。

e:实例赋值给属性、常量或变量，它们都会创建此实例的强引用，只要强引用还在，实例是不允许被销毁的。

class Person {

let name: String

init(name: String) {

self.name = name

print("\(name) 开始初始化")

}

deinit {

print("\(name) 被析构")

}

// 值会被自动初始化为nil，目前还不会引用到Person类的实例

var reference1: Person?

var reference2: Person?

var reference3: Person?

// 创建Person类的新实例

reference1 = Person(name: "Runoob")

//赋值给其他两个变量，该实例又会多出两个强引用

reference2 = reference1

reference3 = reference1

//断开第一个强引用

reference1 = nil

//断开第二个强引用

reference2 = nil

//断开第三个强引用，并调用析构函数

reference3 = nil

// 在OC 中最烦人的就是循环引用，在swift 中也不例外，类实例之间的循环强引用

// 我们可能会写出这样的代码，一个类永远不会有0个强引用。这种情况发生在两个类实例互相保持对方的强引用，并让对方不被销毁。这就是所谓的循环强引用。

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

Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：

a：弱引用

b：无主引用

弱引用和无主引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。

对于生命周期中会变为nil的实例使用弱引用。相反的，对于初始化赋值后再也不会被赋值为nil的实例，使用无主引用。

// 弱引用实例对于生命周期中会变为nil的实例使用弱引用

class Module {

let name: String

init(name: String) { self.name = name }

var sub: SubModule?

deinit { print("\(name) 主模块") }

}

class SubModule {

let number: Int

init(number: Int) { self.number = number }

weak var topic: Module? // 生命周期中会变为nil的实例使用弱引用

deinit { print("子模块 topic 数为 \(number)") }

}

var toc: Module?

var list: SubModule?

toc = Module(name: "ARC")

list = SubModule(number: 4)

toc!.sub = list

list!.topic = toc // 对top 是weak 引用

toc = nil // 当top = nil

list = nil // 因为对top 是weak 引用

// 无主引用实例对于初始化赋值后再也不会被赋值为nil的实例，使用无主引用

class Student {

let name: String

var section: Marks?

init(name: String) {

self.name = name

}

deinit { print("ttt\(name)") }

}

class Marks {

let marks: Int

unowned let stname: Student // 无主引用：Student必不为nil

init(marks: Int, stname: Student) {

self.marks = marks

self.stname = stname

}

deinit { print("学生的分数为 \(marks)") }

}

var module: Student?

module = Student(name: "ARC")

module!.section = Marks(marks: 98, stname: module!)

module = nil // 此时对Marks的引用为0 所以也执行了Marks 的析构函数

// 闭包引起的循环强引用

// 当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性，例如self.someProperty，或者闭包中调用了实例的某个方法，例如self.someMethod。这两种情况都导致了闭包 "捕获" self，从而产生了循环强引用。

// 实例

// 下面的例子为你展示了当一个闭包引用了self后是如何产生一个循环强引用的。例子中定义了一个叫HTMLElement的类，用一种简单的模型表示 HTML 中的一个单独的元素：

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())

paragraph = nil // 之后并没有执行析构函数

HTMLElement 类产生了类实例和 asHTML 默认值的闭包之间的循环强引用。

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

解决闭包引起的循环强引用:在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。

弱引用和无主引用

当闭包和捕获的实例总是互相引用时并且总是同时销毁时，将闭包内的捕获定义为无主引用。

相反的，当捕获引用有时可能会是nil时，将闭包内的捕获定义为弱引用。

如果捕获的引用绝对不会置为nil，应该用无主引用，而不是弱引用。

实例

前面的HTMLElement例子中，无主引用是正确的解决循环强引用的方法。这样编写HTMLElement类来避免循环强引用：

class HTMLElement1 {

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) 被析构\n")

}

//创建并打印HTMLElement实例

var paragraph1: HTMLElement1? = HTMLElement1(name: "p1", text: "hello, world1")

print(paragraph1!.asHTML())

// HTMLElement实例将会被销毁，并能看到它的析构函数打印出的消息

paragraph1 = nil

swift_025（Swift 的自动引用计数(ARC)相关推荐

Swift学习:自动引用计数
swift 使用自动引用计数(ARC)机制来跟踪和管理你的应用程序的内存.通常情况下,swift 内存管理机制会一直起作用,你无须自己来考虑内存的管理.ARC 会在类的实例不再被使用时,自动释放其占用 ...
Swift中文教程（十六）自动引用计数
Swift使用自动引用计数(ARC)来管理应用程序的内存使用.这表示内存管理已经是Swift的一部分,在大多数情况下,你并不需要考虑内存的管理.当实例并不再被需要时,ARC会自动释放这些实例所使用的内 ...
obj-c编程11:内存管理和ARC(自动引用计数)
乖乖隆地洞,这篇文章内容可是不得了,内存管理哦!首先,这个要是搞不明白,你就等着进程莫名其妙的挂死,或是疯狂申请内存却不释放,结果被OS杀死,不管是"自杀"还是"他杀&q ...
Swift2.1 语法指南——自动引用计数
原档: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programm ...
关于oc中自动引用计数小结
1.自动引用计数 ARC(Automatic Reference Counting,自动引用计数)极大地减少了Cocoa开发中的常见编程错误:retain跟release不匹配.ARC并不会消除对re ...
【2015-10-19】内存管理－－－深浅拷贝,autorelease,ARC(自动引用计数)
2019独角兽企业重金招聘Python工程师标准>>> 一.复习内存管理中的MRC(手动管理内存) 1.还是遵循谁retain,谁release的原则: 2.遛狗练习的中途换狗问题, ...
iOS开发之ARC（自动引用计数）
iOS开发之ARC(自动引用计数) 英文原文:Automatic Reference Counting on iOS 参与翻译(4人): 纶巾客, showme, 李远超, 王宇龙自动引用计数(AR ...
【ARC 自动引用计数 Objective-C语言】
前言 ARC , Automatic Reference Counting,自动引用计数,即ARC. 顾名思义:系统自动帮我们去计算对象的引用计数器的值. 可以说,这门技术,是WWDC2011和iOS ...
iOS 自动引用计数和内存泄露
自动引用计数与解决内存泄露自动引用计数主要用于管理和释放内存. 引用计数我们在创建一个对象的时候,系统会为其分配内存,而什么时候和谁来释放对象内存成了问题,如果不释放,就会导致内存不足.所以苹果公 ...

swift_025（Swift 的自动引用计数(ARC)

swift_025（Swift 的自动引用计数(ARC)相关推荐

最新文章

热门文章