本文简单介绍Swift对内存的一些特有操作，比如闭包的循环引用，以及逃逸闭包。Swift为了访问的安全，还增加了访问冲突检查。
主要内容：
- 弱引用
- 循环引用
- 逃逸闭包
- 访问冲突
1. 内存管理
跟OC一样，Swift也是采取基于引用计数的ARC内存管理方案（针对堆空间），Swift的ARC中有3种引用。
2. 弱引用
/*
1、弱引用
*/
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?
说明：
- weak、unowned只能用在类实例上面
- 因为weak可以设置为nil，所以必须用可选项
- 会发生改变，所以需要用var
3. 循环引用
循环引用就是两个对象相互持有，无法释放会导致内存泄漏，和OC一样，所以重点看一下闭包的循环引用，其实也就和block一样
循环引用的解决：weak、unowned 都能解决循环引用的问题，unowned 要比 weak 少一些性能消耗，在生命周期中可能会变为 nil 的使用 weak，初始化赋值后再也不会变为 nil 的使用unowned
3.1 方法闭包的循环引用
p调用fn，fn的闭包内引用了p，所以就造成了循环引用
循环引用：
/*
2、闭包的循环引用
*/
class Person {
var fn: (() -> ())?
func run() { print("run") }
deinit { print("deinit") }
}
func test() {
let p = Person()
p.fn = { p.run() }
}
test()
解决：
class Person {
var fn: (() -> ())?
func run() { print("run") }
deinit { print("deinit") }
}
func test() {
let p = Person()
p.fn = {
[weak p] in
p?.run()
}
}
test()
说明：
1、注意设置弱引用格式
2、弱引用就有可能是nil，所以必须是可选项，而可选项就需要使用？来自动解包，此处不要用!方式，否则nil仍然调用run()崩溃
3、注意这种格式，这个是闭包的写法，所以有in，[weak p]是捕获列表，而不是参数列表。如果需要传入参数后面还要加(age)
3.2 属性闭包的循环引用
循环引用：
class Person {
lazy var fn: (() -> ()) = {
[weak self] in
self?.run()
}
func run() { print("run") }
deinit { print("deinit") }
}
func test() {
let p = Person()
p.fn()
}
test()
说明：
1、lazy的时候，会在调用fn属性时才会调会初始化fn
2、在这个闭包表达式中，这里的self.run()中self是必须要写的，编译器想让开发者可以更清楚的知道这里使用了self，以此知道这里强引用了self
3、为了解决强引用，使用weak进行弱引用设置一下
不产生循环引用：
class Person {
var age: Int = 0
lazy var getAge: Int = {
self.age
}()
deinit { print("deinit") }
}
说明：
4. 逃逸闭包
非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数
4.1 非逃逸闭包
闭包调用发生在函数结束前，闭包调用在函数作用域内
/*
3、逃逸闭包
*/
//非逃逸闭包
import Dispatch
typealias Fn = () -> ()
// fn是非逃逸闭包
func test1(_ fn: Fn) { fn() }
4.2 逃逸闭包
代码：
class Person {
var fn: Fn
// fn是逃逸闭包
init(fn: @escaping Fn) {
self.fn = fn
}
func run() {
// DispatchQueue.global().async也是一个逃逸闭包
// 它用到了实例成员（属性、方法），编译器会强制要求明确写出self
DispatchQueue.global().async {
self.fn()
}
}
}
说明：
- 很明显都是逃逸闭包，因为不在函数内执行完成
- 这个async本身就是一个闭包，所以也必须使用self来调用
- 闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping声明
逃逸闭包不可以捕获inout参数
说明：
1、非逃逸闭包可以捕获inout参数
2、other2虽然本身是非逃逸闭包，但是可以强制设置成逃逸闭包
3、逃逸闭包不能捕获inout参数，会报错
4、因为逃逸闭包的调用时机无法确定，无法修改捕获的外界的值。
5. 访问冲突
Swift对于可能会发生读取冲突的编码错误会进行编译报错
内存访问冲突会在两个访问满足下列条件时发生
条件：
- 至少一个是写入操作
- 它们访问的是同一块内存
- 它们的访问时间重叠（比如在同一个函数体内）
内存访问冲突：
/*
4、内存访问冲突
*/
// 存在内存访问冲突
// Simultaneous accesses to 0x0, but modification requires exclusive access
var step = 1
func increment(_ num: inout Int) { num += step }
increment(&step)
说明：
1、传入的是step，因此num也是step，他们二者访问的是同一份内存
2、step += step 说明step在读取，也在写入
3、在同一个函数内进行的同一个操作语句，因此访问时间重叠
解决冲突：
// 解决内存访问冲突
var copyOfStep = step
increment(©OfStep)
step = copyOfStep
说明：
- 不能同时操作同一份内存
- 其实只要设法三个条件不能同时满足就可以解决冲突
基本数据类型的冲突
说明：
- 第二次调用传入的是num1，所以在y = sum - x时会操作同一份内存
组合类型的冲突
说明：
1、如果操作同一个类型的不同成员，也会报错，整体认为是同一份内存
2、因此这里的同一份内存可以理解为查找该数据时使用的地址（通过首地址的地址偏移来查找的）
重叠访问属性安全的条件：
1、你只访问实例存储属性，不是计算属性或者类属性
2、结构体是局部变量而非全局变量
3、结构体要么没有被闭包捕获要么只被非逃逸闭包捕获
案例：
func balance(_ x: inout Int, _ y: inout Int) {
let sum = x + y
x = sum / 2
y = sum - x
}
struct Player {
var name: String
var health: Int
var energy: Int
mutating func shareHealth(with teammate: inout Player) {
balance(&teammate.health, &health)
}
}
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()
说明：
- 放在函数中，而且访问的是实例存储属性就不会发生冲突
- 满足以上两个条件，那么访问的实例存储属性就是在栈中，栈的特点来说是不会冲突的（生命周期短，作用域只在栈中）
