内存管理
跟OC一样，Swift也是采取基于引用计数的ARC内存管理方案（针对堆空间）.
Swift的ARC中有3种引用:
1)强引用（strong reference）：默认情况下，引用都是强引用
2)弱引用（weak reference）：通过weak定义弱引用
- 必须是可选类型的
var，因为实例销毁后，ARC会自动将弱引用设置为nil - ARC自动给弱引用设置
nil时，不会触发属性观察器
3)无主引用（unowned reference）：通过unowned定义无主引用.
- 不会产生强引用，实例销毁后仍然存储着实例的内存地址（类似于OC中的unsafe_unretained）
- 试图在实例销毁后访问无主引用，会产生运行时错误（野指针）
Fatal error: Attempted to read an unowned reference but object 0x0 was already deallocated
weak、unowned的使用限制
- weak、unowned只能用在
类实例上面
protocol Livable : AnyObject {}
class Person {}
weak var p0: Person?
weak var p1: AnyObject?
weak var p2: Livable?
unowned var p10: Person?
unowned var p11: AnyObject?
unowned var p12: Livable?
Autoreleasepool
public func autoreleasepool<Result>(invoking body: () throws -> Result) rethrows -> Result
autoreleasepool {
let p = MJPerson(age: 20, name: "Jack")
p.run()
}
循环引用（Reference Cycle）
-
weak、unowned都能解决循环引用的问题，unowned要比weak少一些性能消耗 - 在生命周期中可能会变为 nil 的使用
weak - 初始化赋值后再也不会变为 nil 的使用
unowned
闭包的循环引用
- 闭包表达式默认会对用到的外层对象产生额外的强引用（对外层对象进行了retain操作）
- 下面代码会产生循环引用，导致Person对象无法释放（看不到Person的deinit被调用）
class Person {
var fn: (() -> ())?
func run() { print("run") }
deinit { print("deinit") }
}
func test() {
let p = Person()
p.fn = { p.run() }
}
test()
解决闭包的循环引用:
在闭包表达式的捕获列表声明weak或unowned引用，解决循环引用问题
p.fn = {
[weak p] in
p?.run()
}
p.fn = {
[unowned p] in
p.run()
}
- 捕获列表可以定义新的名称
p.fn = {
[weak wp = p, unowned up = p, a = 10 + 20] in
wp?.run()
}
闭包的self
- 1)如果想在定义闭包属性的同时引用
self，这个闭包必须是lazy的（因为在实例初始化完毕之后才能引用self）
class Person {
lazy var fn: (() -> ()) = {
[weak self] in
self?.run()
}
func run() { print("run") }
deinit { print("deinit") }
}
func test(){
var p = Person()
p.fn()
}
test()
- 左边的闭包fn内部如果用到了实例成员（属性、方法）
- 编译器会强制要求明确写出self
- 2)如果
lazy属性是闭包调用的结果，那么不用考虑循环引用的问题（因为闭包调用后，闭包的生命周期就结束了）
class Person {
var age: Int = 0
//getAge本质是Int类型, 不是闭包
lazy var getAge: Int = {
self.age
}()
deinit { print("deinit") }
}
func test(){
var p = Person()
print(p.getAge)
}
test()
@escaping
非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数:
- 非逃逸闭包：闭包调用发生在函数结束前，闭包调用在函数作用域内
-
逃逸闭包：闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过
@escaping声明
import Dispatch
typealias Fn = () -> ()
// fn是非逃逸闭包
func test1(_ fn: Fn) { fn() }
// fn是逃逸闭包
var gFn: Fn?
func test2(_ fn: @escaping Fn) { gFn = fn }
// fn是逃逸闭包
func test3(_ fn: @escaping Fn) {
DispatchQueue.global().async {
fn()
}
}
class Person {
var fn: Fn
// fn是逃逸闭包
init(fn: @escaping Fn) {
self.fn = fn
}
func run() {
// DispatchQueue.global().async也是一个逃逸闭包
// 它用到了实例成员（属性、方法），编译器会强制要求明确写出self
DispatchQueue.global().async {
self.fn()
//如果Person对象销毁不再执行闭包,可以这样写
//[weak weakSelf = self] in
//weakSelf?.fn()
}
}
}
逃逸闭包的注意点
- 逃逸闭包不可以捕获inout参数
typealias Fn = () -> ()
func other1(_ fn: Fn) { fn() }
func other2(_ fn: @escaping Fn) { fn() }
func test(value: inout Int) -> Fn {
other1 { value += 1 }
// error: 逃逸闭包不能捕获inout参数
other2 { value += 1 }
func plus() { value += 1 }
// error: 逃逸闭包不能捕获inout参数
return plus
}
内存访问冲突（Conflicting Access to Memory）
内存访问冲突会在两个访问满足下列条件时发生：
(在全局作用域中)
- 至少一个是写入操作
- 它们访问的是同一块内存
- 它们的访问时间重叠（比如在同一个函数内）
// 不存在内存访问冲突
func plus(_ num: inout Int) -> Int { num + 1 }
var number = 1
number = plus(&number)
存在内存访问冲突
// 存在内存访问冲突
// Simultaneous accesses to 0x0, but modification requires exclusive access
var step = 1
func increment(_ num: inout Int) { num += step }
increment(&step)
解决内存访问冲突
// 解决内存访问冲突
var copyOfStep = step
increment(©OfStep)
step = copyOfStep
内存访问冲突示例
1)同时访问同一变量内存地址
func balance(_ x: inout Int, _ y: inout Int) {
let sum = x + y
x = sum / 2
y = sum - x
}
var num1 = 42
var num2 = 30
balance(&num1, &num2) // OK
balance(&num1, &num1) // Error
2)同时访问同一对象属性内存地址
struct Player {
var name: String
var health: Int
var energy: Int
mutating func shareHealth(with teammate: inout Player) {
balance(&teammate.health, &health)
}
}
var oscar = Player(name: "Oscar", health: 10, energy: 10)
var maria = Player(name: "Maria", health: 5, energy: 10)
oscar.shareHealth(with: &maria) // OK
oscar.shareHealth(with: &oscar) // Error
//同时访问同一对象属性health内存地址
3)同时访问同一元组内存地址
var tulpe = (health: 10, energy: 20)
// Error
balance(&tulpe.health, &tulpe.energy)
var holly = Player(name: "Holly", health: 10, energy: 10)
// Error
balance(&holly.health, &holly.energy)
//health和energy在元组中属于同一块内存
内存访问冲突示例二
如果下面的条件可以满足，就说明重叠访问结构体的属性是安全的:
(在局部作用域中)
- 你只访问实例存储属性，不是
计算属性或者类属性 - 结构体是
局部变量而非全局变量 - 结构体要么
没有被闭包捕获要么只被非逃逸闭包捕获
// Ok
func test() {
var tulpe = (health: 10, energy: 20)
balance(&tulpe.health, &tulpe.energy)
var holly = Player(name: "Holly", health: 10, energy: 10)
balance(&holly.health, &holly.energy)
}
test()
网友评论