一. 关于引用
跟OC一样，Swift也是采取基于引用计数的ARC内存管理方案
ARC的引用计数管理一般是针对堆空间，如果是全局区、栈空间等都不用你管。
Swift的ARC中有3种引用：
- 强引用（strong reference）：默认情况下，引用都是强引用
- 弱引用（weak reference）：通过weak定义弱引用
① 必须是可选类型的var，因为实例销毁后，ARC会自动将弱引用设置为nil
② ARC自动给弱引用设置nil时，不会触发属性观察器 - 无主引用（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? //Person实例
weak var p1: AnyObject? //任何类实例
weak var p2: Livable? //Livable协议只能被类遵守，所以可以用weak
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
官方示例的循环引用
使用weak解决
使用unowned解决
1. 什么是闭包
首先回忆下什么是闭包？
Swift闭包：一个函数和它所捕获的变量\常量环境组合起来，称为闭包，可以把闭包想象成是一个类的实例对象。
一般指定义在函数内部的函数。
一般它捕获的是外层函数的局部变量\常量。
参考OC的block定义：block是封装了函数调用以及函数调用环境的OC对象。
2. 闭包的循环引用
- 闭包表达式默认会对用到的外层对象产生额外的强引用（对外层对象进行了retain操作）
下面代码会产生循环引用，导致Person对象无法释放（看不到Person的deinit被调用）。
class Person {
var fn: (() -> ())?
func run() { print("run") }
deinit { print("deinit") }
}
func test() {
let p = Person()
//{ p.run() }是个闭包,它引用着p,p里面又引用着这个闭包,所以会产生循环引用导致p无法被释放
p.fn = { p.run() }
}
test()
- 在闭包表达式的捕获列表声明weak或unowned引用，解决循环引用问题
p.fn = {
[weak p] in
p?.run() //weak引用必须是可选类型，因为可能为nil，所以用p?
}
p.fn = {
[unowned p] in
p.run()
}
p.fn = {
//[]中是捕获列表，一般写在参数列表前面并且可以定义新的名称
[weak wp = p, unowned up = p, a = 10 + 20] in
wp?.run()
}
- 如果想在定义闭包属性的同时用实例成员(属性、方法)，这个闭包必须是lazy
因为在实例初始化完毕之后才能引用self，如果不加lazy就是初始化Person的时候也要使用self，显然是不行的。
class Person {
lazy var fn: (() -> ()) = {
[weak self] in
self?.run() //编译器强制要求写出self
}
func run() { print("run") }
deinit { print("deinit") }
}
- 上面的闭包fn内部如果用到了实例成员(属性、方法)，编译器会强制要求写出self
强制要求写出self的原因就是告诉开发者，要想好使用什么样的self（强引用、弱引用、无主引用），如果不写，会报错：Call to method 'run' in closure requires explicit 'self.' to make capture semantics explicit（在闭包中对方法“run”的调用需要显式的“self.”，以使捕获语义显式）。
- 如果lazy属性是闭包调用的结果，那么不用考虑循环引用的问题（因为闭包调用后，闭包的生命周期就结束了）
class Person {
var age: Int = 0
lazy var getAge: Int = {
self.age
}() //后面有个()，就是声明一个闭包，然后马上调用
deinit { print("deinit") }
}
//person只是拥有int类型的age并没有拥有闭包，所以不会产⽣循环引⽤
三. @escaping
- 非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数
- 非逃逸闭包：闭包调用发生在函数结束前，闭包调用在函数作用域内
- 逃逸闭包：闭包调用有可能在函数结束后，闭包调用逃离了函数的作用域，需要通过@escaping声明
import Dispatch
typealias Fn = () -> ()
// fn是非逃逸闭包
func test1(_ fn: Fn) { fn() }
var gFn: Fn?
// fn是逃逸闭包
func test2(_ fn: @escaping Fn) { gFn = fn } //fn没有调用，而是传递给了gFn，有可能在函数结束后调用
// fn是逃逸闭包
func test3(_ fn: @escaping Fn) {
DispatchQueue.global().async {
fn() //因为是全局并发队列，所以fn的调⽤有可能在函数作⽤域之外
}
}
- 为什么逃逸闭包要明显写出@escaping？
如下代码：
import Dispatch
class Person {
func run(_ fn: @escaping ()-> ()) {
DispatchQueue.global().async {
fn()
}
}
}
上面代码，run方法调用完之后person对象有可能被销毁，这时候如果在别的线程再调用fn，fn里面有可能会用到person里面的东西，person都死了，这时候最终调用fn的结果就可能会不一样，有风险，所以让你明显写出@escaping，提醒开发者，就是为了安全。
- 逃逸闭包里面用到了实例成员(属性、方法)，编译器会强制要求写出self
强制要求写出self的原因就是告诉开发者，要想好使用什么样的self（强引用、弱引用、无主引用）
import Dispatch
typealias 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() // 它用到了实例成员（属性、方法），编译器会强制要求写出self
} //这里不会产生循环引用，虽然闭包引用了self，但是person并没有引用闭包
}
}
通过查看DispatchQueue.global().async定义，可以知道它是一个逃逸闭包，如下：
public func async(group: DispatchGroup? = nil, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], execute work: @escaping @convention(block) () -> Void)
//@convention(block)代表传入的是和OC的block类似的东西，在Swift中就是闭包
//@escaping代表是逃逸闭包
为什么逃逸闭包里面强制要求写出self？
- 如果是非逃逸闭包，就算闭包里面对self产生了强引用，那这个强引用也是在run方法里面销毁了，不会对person的生命周期产生额外的影响。
- 如果是逃逸闭包，因为DispatchQueue.global().async是个逃逸闭包，逃逸闭包可能是在run调用完之后才调用的。
假如run调用完，接下来执行逃逸闭包里面的代码self.fn()，如果这时候person想销毁(person的其他引用都没了)，由于闭包对self产生的默认是强引用，所以person不会被销毁，最后fn调用完之后person才销毁，这时候也是暗示开发者要不要写weak，如下：
① 如果想要person死了，这个闭包就不调用了，就使用weak，代码:[weak self] in self?.fn()，例如:VC死了，⼜弹出⼀个⽹络错误请求。
② 如果想要闭包调⽤之后person再死，就self.fn()，闭包对person默认产生⼀次强引⽤。
- 逃逸闭包不可以捕获inout参数
typealias Fn = () -> ()
func other1(_ fn: Fn) { fn() }
func other2(_ fn: @escaping Fn) { fn() } //把fn当成逃逸闭包，虽然它不是
func test(value: inout Int) -> Fn {
other1 { value += 1 } //非逃逸闭包可以捕获inout参数
// error: 逃逸闭包不能捕获inout参数
other2 { value += 1 }
func plus() { value += 1 }
// error: 逃逸闭包不能捕获inout参数
return plus //返回一个逃逸闭包
}
因为如果逃逸闭包捕获了inout参数，调⽤逃逸闭包的时候那个inout参数可能已经被释放了，所以不允许这样做。
四. 内存访问冲突（Conflicting Access to Memory）
内存访问冲突会在两个访问满足下列条件时发生：
- 至少一个是写入操作
- 它们访问的是同一块内存
- 它们的访问时间重叠（比如在同一个函数内）
- 内存访问冲突示例1：
//不存在内存访问冲突：
func plus(_ num: inout Int) -> Int { num + 1 }
var number = 1
number = plus(&number)
//存在内存访问冲突：
var step = 1
//报错：Simultaneous accesses to 0x0, but modification requires exclusive access
func increment(_ num: inout Int) { num += step }
increment(&step)
//上面的{ num += step }就相当于{ step += step }，这里有两处操作，左边的step是写入操作，右边的step是访问step的内存，所以存在内存访问冲突
//解决内存访问冲突：
var step = 1
func increment(_ num: inout Int) { num += step }
var copyOfStep = step //先将step的值拷贝给copyOfStep
increment(©OfStep) //copyOfStep累加step后的值赋值给copyOfStep
step = copyOfStep //最后把copyOfStep赋值给step
- 内存访问冲突示例2：
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，内存访问冲突，因为访问的是同一块内存
- 内存访问冲突示例3：
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，传入的是自己的地址，所以会内存访问冲突
- 内存访问冲突示例4：
//下面重叠访问元祖、结构体也会有内存访问冲突：
var tulpe = (health: 10, energy: 20)
balance(&tulpe.health, &tulpe.energy) // Error，访问的都是元祖那一块整体的内存，所以会报错
var holly = Player(name: "Holly", health: 10, energy: 10)
balance(&holly.health, &holly.energy) // Error，访问的都是结构体那一块整体的内存，所以会报错
如果下面的条件可以满足，就说明重叠访问结构体的属性是安全的
- 你只访问实例存储属性，不是计算属性或者类属性
- 结构体是局部变量而非全局变量
- 结构体要么没有被闭包捕获要么只被非逃逸闭包捕获（要么就没闭包，如果有闭包的话只能是⾮逃逸闭包）
//如果将上面代码放到函数里面，就不会报错了
//放到函数里面，tulpe、holly的内存其实都在栈空间，tulpe、holly只有test(){}内部可以访问，外面访问不了，是安全的
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()
五. 指针
1. 关于指针
Swift中也有专门的指针类型，这些都被定性为“Unsafe”（不安全的），常见的有以下4种类型：
- UnsafePointer<Pointee> 类似于 const Pointee *
- UnsafeMutablePointer<Pointee> 类似于 Pointee *
- UnsafeRawPointer 类似于 const void *
- UnsafeMutableRawPointer 类似于 void *
其中1、2是带泛型的，3、4是不带泛型的。
对于带泛型的：
var age = 10
func test1(_ ptr: UnsafeMutablePointer<Int>) { //等价于 Int * ，可以修改
ptr.pointee += 10
}
func test2(_ ptr: UnsafePointer<Int>) { //等价于 const Int * ，不能修改
print(ptr.pointee) //使用pointee取出指针指向的数据
}
test1(&age)
test2(&age) // 20
print(age) // 20
小结论：Swift中传入地址值的要么是输入输出参数，要么是现在讲的指针类型
对于不带泛型的：
var age = 10
func test3(_ ptr: UnsafeMutableRawPointer) { //等价于 void * ，可以修改
ptr.storeBytes(of: 20, as: Int.self) //将20当做Int类型数据存进去
}
func test4(_ ptr: UnsafeRawPointer) { //等价于 const void * ，不能修改
print(ptr.load(as: Int.self)) //取出Int类型数据
}
test3(&age)
test4(&age) // 20
print(age) // 20
- 指针的应用示例
数组的遍历：
var arr = NSArray(objects: 11, 22, 33, 44)
arr.enumerateObjects { (obj, idx, stop) in
print(idx, obj)
if idx == 2 { // 下标为2就停止遍历
stop.pointee = true
}
}
//上面的stop，在OC里面是 BOOL * 类型，如果OC里面想要暂停遍历，就设置 *stop = YES，就是将指针指向的东西设置为YES
//在Swift里面stop是UnsafeMutablePointer<ObjCBool>类型，如果想要暂停遍历直接 stop.pointee = true 就可以了
其实在Swift中遍历数组更推荐以下方式：
var arr = NSArray(objects: 11, 22, 33, 44)
for (idx, obj) in arr.enumerated() {
print(idx, obj)
if idx == 2 {
break
}
}
2. 获得指向某个变量的指针
var age = 11
var ptr1 = withUnsafeMutablePointer(to: &age) { $0 } //获得指向age变量的指针，可修改
var ptr2 = withUnsafePointer(to: &age) { $0 } //获得指向age变量的指针，不可修改
ptr1.pointee = 22
print(ptr2.pointee) // 22
print(age) // 22
上面代码解释：withUnsafeMutablePointer 第⼀个参数是指向age的指针，第⼆个参数是个闭包，这个闭包传进去那个指针，返回Result，这个Result和整个函数返回的Result的⼀ 致，现在我们就想把指向age的指针传出去，所以直接写$0也⼀样 (代表你传给我最前⾯的参数，就是指向age的指针)
上面返回的是带泛型的指针，如何返回无泛型的指针？如下：
var ptr3 = withUnsafeMutablePointer(to: &age) { UnsafeMutableRawPointer($0) }
var ptr4 = withUnsafePointer(to: &age) { UnsafeRawPointer($0) }
ptr3.storeBytes(of: 33, as: Int.self)
print(ptr4.load(as: Int.self)) // 33
print(age) // 33
上面代码解释：UnsafeRawPointer($0) 是把UnsafePointer转换成UnsafeRawPointer类型的指针
3. 获得指向堆空间实例的指针
传入地址，包装成指针：
var ptr = UnsafeRawPointer(bitPattern: 0x100001234)
//默认不指向其他东⻄
方法一：
class Person {
var age: Int
init(age: Int) {
self.age = age
}
}
var person = Person(age: 21)
//传入的是person变量的地址值，所以ptr里面存储的就是person变量的地址值
var ptr = withUnsafePointer(to: &person) { UnsafeRawPointer($0) }
//这个函数的作用是：传入一个地址值，包装成指针。ptr.load是获取ptr指针里面存储的东西(就是堆空间Person对象的地址值)
var heapPtr = UnsafeRawPointer(bitPattern: ptr.load(as: UInt.self))
//ptr是person变量的地址值，⽽不是堆空间Person对象的地址值，所以 ptr.pointee.age = 10 和 person.age = 10 等价
通过打印也可以验证：ptr是person变量的地址值，heapPtr是堆空间Person对象的地址值，如下：
//打印指针就是打印指针存储的地址值
print(ptr) //person变量的地址值
print(heapPtr!) //堆空间Person对象的地址值
print(Mems.ptr(ofVal: &person)) //person变量的地址值
print(Mems.ptr(ofRef: person)) //堆空间Person对象的地址值
//0x0000000100007a20
//0x0000000100620c00
//0x0000000100007a20
//0x0000000100620c00
小技巧：一般10000这样的地址是代码段或者全局区，100xx这样的地址是堆空间
方法二：使用unsafeBitCast，进行忽略数据类型的强制转换 (关于unsafeBitCast更详细的可见文末)
class Person {}
var person = Person()
//unsafeBitCast函数有两个参数，第一个参数是想转换谁，第二个参数是转换成什么类型
var ptr = unsafeBitCast(person, to: UnsafeRawPointer.self)
print(ptr)
//获取指向堆空间实例的指针，更简单的⽅法
4. 创建指针
上面都是根据已有的变量，然后搞一个指针指向这个已有的变量，那么如何凭空创建一个指针，不指向任何东西，在后面我们再让它指向某一块堆空间呢？
方法一：使用malloc
// 创建
var ptr = malloc(16) //申请16字节
// 存
ptr?.storeBytes(of: 11, as: Int.self) //前8字节放11
ptr?.storeBytes(of: 22, toByteOffset: 8, as: Int.self) //后8字节放22
// 取
print((ptr?.load(as: Int.self))!) // 11 取出前8字节
print((ptr?.load(fromByteOffset: 8, as: Int.self))!) // 22 取出后8字节
// 销毁
free(ptr)
方法二：使用UnsafeMutableRawPointer
var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1) //申请16字节 对齐一般写1
ptr.storeBytes(of: 11, as: Int.self)
ptr.advanced(by: 8).storeBytes(of: 22, as: Int.self) //advanced(by: 8是获取ptr后8字节的指针，然后拿到指针把22存进去
print(ptr.load(as: Int.self)) // 11 取出前8字节
print(ptr.advanced(by: 8).load(as: Int.self)) // 22 取出后8字节
ptr.deallocate() //销毁
方法三：使用UnsafeMutablePointer<Pointee>
//这种带有泛型Int的指针，创建的时候传入容量就可以了
var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 3) //容量是3，每个Int占用8字节，就是⼀共申请24个字节
ptr.initialize(to: 11) //前8初始化为11
ptr.successor().initialize(to: 22) //跳8字节
ptr.successor().successor().initialize(to: 33) //再跳8字节
//sucessor是后记，就是如果ptr是指向前8字节的Int，那么它的后记就是指向后8字节的Int，再来个后记就是再指向下一个Int，说白了就是跳8字节
print(ptr.pointee) // 11
print((ptr + 1).pointee) // 22 ptr + 1就相当于ptr.successor()
print((ptr + 2).pointee) // 33 ptr + 2就相当于ptr.successor().successor()
print(ptr[0]) // 11
print(ptr[1]) // 22
print(ptr[2]) // 33 //这三句和上⾯三句完全⼀样的
ptr.deinitialize(count: 3) //调⽤了initilalize初始化了三个家伙，所以反初始化三次，这个一定要注意，不然会有内存泄漏
ptr.deallocate()
方法三的举例：创建指针，存着person对象
class Person {
var age: Int
var name: String
init(age: Int, name: String) {
self.age = age
self.name = name
}
deinit { print(name, "deinit") }
}
var ptr = UnsafeMutablePointer<Person>.allocate(capacity: 3)
ptr.initialize(to: Person(age: 10, name: "Jack"))
(ptr + 1).initialize(to: Person(age: 11, name: "Rose"))
(ptr + 2).initialize(to: Person(age: 12, name: "Kate"))
// Jack deinit
// Rose deinit
// Kate deinit
ptr.deinitialize(count: 3)
ptr.deallocate()
上面一定要调用ptr.deinitialize(count: 3)，这样三个person对象才会销毁，不然会有内存泄漏
5. 指针之间的转换
⽆泛型 -> 有泛型 : UnsafeMutableRawPointer —>UnsafePointer<Pointee>
var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
//没有把UnsafeRawPointerr转换成UnsafePointe类型指针的初始化⽅法，所以⽤assumingMemoryBound指定我存的是什么类型的数据
ptr.assumingMemoryBound(to: Int.self).pointee = 11 //assuming是假想的意思，就是假想是Int数据
(ptr + 8).assumingMemoryBound(to: Double.self).pointee = 22.0
//unsafeBitCast函数有两个参数，第一个参数是想转换谁，第二个参数是转换成什么类型
print(unsafeBitCast(ptr, to: UnsafePointer<Int>.self).pointee) // 11
print(unsafeBitCast(ptr + 8, to: UnsafePointer<Double>.self).pointee) // 22.0
ptr.deallocate()
补充：unsafeBitCast原理
先看转换，如果是不忽略数据类型的改变的转换，就是下面这样，最后他们内存中存储数据的格式改变了，如下：
var age = 10
var age1 = Double(age)
//age和age1内存中的0101二进制格式是不⼀样的
//如果是整数，内存中就是：0x00 00 00 00 00 00 00 0A
//如果是Double，内存中存储的就不是上面那样了，因为牵扯到科学计数法、指数等等
unsafeBitCast是忽略数据类型的强制转换，不会因为数据类型的变化而改变原来的内存数据(类似于C++中的reinterpret_cast)，如下：
var age = 10
var age1 = unsafeBitCast(age, to: Double.self)
print(age,age1) //10 5e-323
上面代码，是忽略数据类型的强制转换，age和age1内存中存储的都是0x00 00 00 00 00 00 00 0A，所以，对于age打印是10，但是对于age1使用了浮点数类型的打印格式，所以最后打印的就是不准确的数据(5e-323是指数的写法)
但是，忽略数据类型的强制转换对于指针是没有任何影响的，因为大家都是指针，存储的都是地址值。
就比如下面，person变量里面存储的就是堆空间Person对象的地址值，使用unsafeBitCast转换就相当于把它搬过来，所以ptr里面存储的就是堆空间Person对象的地址值
class Person {}
var person = Person()
var ptr = unsafeBitCast(person, to: UnsafeRawPointer.self)
print(ptr)
//获取指向堆空间实例的指针，更简单的⽅法
