Swift 和 OC 的 ARC 很相似
ARC 工作原理
- 创建一个类的实例，ARC 为实例分配内存
- 当类不再需要，ARC 释放内存并能为其他地方使用。确保实例不再需要时不会消耗内存
- 如果还在使用 ARC 释放的实例，将不能访问该实例属性或方法，并且很可能会引起崩溃
- 分配一个类实例到属性、常量、变量，它们将会强引用实例。只要强引用存在，它将不会被释放
Code For Strong Reference
class Person {
let name: String
init(name: String) {
self.name = name
print("\(name) is being initialized")
}
deinit {
print("\(name) is being deinitialized")
}
}
var reference1: Person?
var reference2: Person?
var reference3: Person?
// 三个强引用
reference1 = Person(name: "Reference")
reference2 = reference1
reference3 = reference1
reference1 = nil
reference2 = nil
// 这时候 Person 还没有释放，还剩下最后一个强引用
// 被释放，调用 deinit
reference3 = nil
解决循环引用的三种方法
- weak reference
- unowned reference
- unowned reference & unwrapped optional property
Weak Reference
场景：两个实例变量均保持各自的强引用
强引用
- john (strong) Person instance && unit4A (strong) Apartment instance
- john.apartment (strong) Apartment instance && unit4A.tenant (strong) Person instance
- john 和 unit4A 引用计数均为 2
- 当 john = nil，Person instance 引用计数为 1，Apartment instance 依旧持有 Person instance
- 当 unit4A = nil，Apartment instance 引用计数为 1，Person instance 依旧持有 Apartment instance
- Apartment instance 和 Person instance 相互持有
弱引用
- john (strong) Person instance && unit4A (strong) Apartment instance
- john.apartment (strong) Apartment instance && unit4A.tenant (weak) Person instance
- john 引用计数为 1、unit4A 引用计数为2
- 当 john = nil，john 引用计数为 0，Apartment instance 弱引用 Person instance，Person instance 释放
- unit4A.tenant = nil，unit4A 引用计数为 1
- 当 unit4A = nil，unit4A 引用计数为 0，Apartment instance 释放
weak feature
- weak 修饰属性实例的生命周期比持有属性的实例生命周期短
- weak 关键字修饰属性或变量
- weak 引用实例释放，置nil，所以修饰对象为可选变量
- ARC 下 weak 引用置 nil，属性观察者不会被调用
- 在垃圾回收系统中，弱指针有时候被用于实现简单的缓存机制，因为只有当内存压力触发垃圾回收时，没有强引用的对象才会被释放。但是在 ARC 中，实例在最后一个强引用被移除后就被释放。（疑惑：下面代码实际执行后，发现并没有立即释放）
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 Reference
weak var tenant: Person?
deinit {
print("Apartment \(unit) is being deinitialized")
}
}
// Optional
var john: Person?
var unit4A: Apartment?
john = Person(name: "Person")
unit4A = Apartment(unit: "unit4A")
// 强制解包
john!.apartment = unit4A
unit4A!.tenant = john
john = nil
unit4A = nil
Unowned Reference
- 像 Weak Reference 一样不会强保持一个实例
- 修饰属性实例比持有属性的实例有相同或更长生命周期
- ARC 下 Unowned Reference 不会被置 nil，即不能定义为 Optional
- 对已释放的实例尝试访问，会导致报错
无主引用
- customer (strong) CreditCard instance
- customer.card (strong) CreditCard instance && (CreditCard instance).customer (unowned) Customer instance
- customer 引用计数为 1
- 当 customer = nil，customer 引用计数为 0 释放，CreditCard instance 也没有强引用释放
CreditCard 必须依赖一个 Customer，Customer 可以没有 CreditCard
class Customer {
let name: String
var card: CreditCard?
init(name: String) {
self.name = name
}
deinit {
print("\(name) is being deinitialized")
}
}
class CreditCard {
// 为了满足在 32 和 64 位系统中有足够大内存存储 16 位数字
// 是 UInt64 而不是 Int
// Int16 等于 short，占用 2 个字节，-32768 ~ 32767
// Int32 等于 int，占用 4 个字节，-2147483648 ~ 2147483647
// Int64 等于 long，占用 8 个字节，-9223372036854775808 ~ 9223372036854775807
// Int8 占用 1 个字节
let number: UInt64
// unowned reference
unowned let customer: Customer
init(number: UInt64, customer: Customer) {
self.number = number
self.customer = customer
}
deinit {
print("Card #\(number) is being deinitialized")
}
}
var customer: Customer?
customer = Customer(name: "Customer")
customer!.card = CreditCard(number: 1234_5678_9012_3456, customer: customer!)
customer = nil
unsafe unowned reference
- 不需要运行时安全检查时使用，例如性能优化，但是需要检查代码安全
- unowned(unsafe) 修饰
- 不安全操作：如果尝试访问一个被 unowned(unsafe) 引用且释放了实例，程序将会访问实例被使用的内存位置
闭包循环引用
- 避免闭包循环引用，添加 capture list
- Swift 要求在闭包中写 self.someProperty 而不是 someProperty，时刻提醒该位置是有捕获 self 的
以下是引起循环引用的代码示例
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")
}
}
capture list 中的 weak 和 unowned
- unowned: 互相持有，将在同一时间释放（如果 reference 永不为 nil，使用 unowned）
- weak: weak reference 在未来某个时刻会 nil，weak reference 总是可选类型
以下是解决循环引用的代码示例
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: () -> String = {
[unowned self]
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")
}
}
其他示例
lazy var someClosure: (int, String) -> String = {
[unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> in
// body
}
lazy var someClosure: () -> String = {
[unowned self, weak delegate = self.delegate!] in
// body
}
网友评论