Swift使用自动引用计数（ARC）这一机制来跟踪和管理应用程序的内存。通常情况下我们不需要去手动释放内存，因为ARC会在类的实例不再被使用时，自动释放其占用的内存。但有些时候还是需要在代码中实现内存管理。
- 当每次使用 init() 方法创建一个类的新的实例的时候，ARC会分配一大块内存用于存储实例的信息。
- 内存中包含实例的类型信息，以及这个实例所有相关属性
- 当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用
- 为了确保使用中实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性、常量、和变量所引用。
- 实例赋值给属性、变量、常量他们都会创建实例的强引用，只要强引用还在没实力是不允许被销毁的。
class Person {
let name: String
init(name: String) {
self.name = name
print("\(name) 开始实例化")
}
deinit {
print("\(name) 被析构")
}
}
var person1: Person?
var person2: Person?
var person3: Person?
person1 = Person(name: "小强五号")
person2 = person1
person3 = person1
person1 = nil
print("断开第1个引用 person1")
person2 = nil
print("断开第2个引用 person2")
person3 = nil
print("断开第3个引用 person3")
输出的结果为：
小强五号 开始实例化
断开第1个引用 person1
断开第2个引用 person2
小强五号 被析构
断开第3个引用 person3
类实例之间的循环引用
class Person {
let name: String
var apartment: Apartment?
init(name: String) {
self.name = name
}
deinit {
print("person 被析构")
}
}
class Apartment {
let number: Int
var tenant: Person?
init(number: Int) {
self.number = number
}
deinit {
print("Apartment 被析构")
}
}
var per: Person?
var apa: Apartment?
per = Person(name: "小强")
apa = Apartment(number: 100)
per?.apartment = apa
apa?.tenant = per
per = nil
apa = nil
解决实例之间的循环强引用
Swift提供了两种办法来解决你在使用类的属性时所晕倒的循环强引用问题：
- 弱引用
- 无主引用
弱引用和无助引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例相互引用而不产生循环强引用。对于生命周期中会变为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?
deinit { print("子模块 topic 数为 \(number)") }
}
var toc: Module?
var list: SubModule?
toc = Module(name: "ARC")
list = SubModule(number: 4)
toc!.sub = list
list!.topic = toc
toc = nil
list = nil
以上程序执行输出结果为：
ARC 主模块
子模块 topic 数为 4
无主引用
class Student {
let name: String
var section: Marks?
init(name: String) {
self.name = name
}
deinit { print("\(name)") }
}
class Marks {
let marks: Int
unowned let stname: Student
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
以上程序执行输出结果为：
ARC
学生的分数为 98
闭包引起的循环引用
循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性，例如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())
HTMLElement 类产生了类实例和 asHTML 默认值的闭包之间的循环强引用。
实例的 asHTML 属性持有闭包的强引用。但是，闭包在其闭包体内使用了self（引用了self.name和self.text），因此闭包捕获了self，这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用。
解决闭包引起的循环强引用:在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。
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())
HTMLElement 类产生了类实例和 asHTML 默认值的闭包之间的循环强引用。
实例的 asHTML 属性持有闭包的强引用。但是，闭包在其闭包体内使用了self（引用了self.name和self.text），因此闭包捕获了self，这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用。
解决闭包引起的循环强引用:在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。
