iOS-Swift-内存管理

一. 关于内存管理

跟OC一样，Swift也是采取基于引用计数的ARC内存管理方案
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? //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 少一些性能消耗

1. 在生命周期中可能会变为 nil 的使用 weak
2. 初始化赋值后再也不会变为 nil 的使用 unowned

官方示例的循环引用 使用weak解决 使用unowned解决

1. 闭包的循环引用

① 闭包表达式默认会对用到的外层对象产生额外的强引用（对外层对象进行了retain操作）

下面代码会产生循环引用，导致Person对象无法释放（看不到Person的deinit被调用）

class Person {
    var fn: (() -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}
func test() {
    let p = Person()
    //这个闭包对外面的p对象产生强引用，外面的p对象内部又有一个fn引用着闭包，所以产生循环引用
    p.fn = { p.run() } 
}
test()

② 在闭包表达式的捕获列表声明weak或unowned引用，解决循环引用问题

p.fn = {
    [weak p] in
    p?.run() //weak引用必须是可选类型，所以用p?
}

p.fn = {
    [unowned p] in
    p.run()
}

p.fn = {
    [weak wp = p, unowned up = p, a = 10 + 20] in
    wp?.run()
}
//[weak wp = p, unowned up = p, a = 10 + 20] 是捕获列表，一般写在参数列表前面并且可以定义新的名称

③ 如果想在定义闭包属性的同时引用self，这个闭包必须是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

1. 非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数
2. 非逃逸闭包：闭包调用发生在函数结束前，闭包调用在函数作用域内
3. 逃逸闭包：闭包调用有可能在函数结束后，闭包调用逃离了函数的作用域，需要通过@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的原因就是告诉开发者，要想好使用什么样的self（强引用、弱引用、无主引用）

import Dispatch
typealias Fn = () -> ()

class Person {
    var fn: Fn
    // fn是逃逸闭包
    init(fn: @escaping Fn) {
        self.fn = fn
    }
    func run() {
        DispatchQueue.global().async {  // 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？

1. 如果是非逃逸闭包，就算闭包里面对self产生了强引用，那这个强引用也是在run方法里面销毁了，不会对person的生命周期产生额外的影响。
2. 如果是逃逸闭包，因为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. 至少一个是写入操作
2. 它们访问的是同一块内存
3. 它们的访问时间重叠（比如在同一个函数内）

• 内存访问冲突示例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(&copyOfStep) //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，访问的都是结构体那一块整体的内存，所以会报错

如果下面的条件可以满足，就说明重叠访问结构体的属性是安全的

1. 你只访问实例存储属性，不是计算属性或者类属性
2. 结构体是局部变量而非全局变量
3. 结构体要么没有被闭包捕获要么只被非逃逸闭包捕获（要么就没闭包，如果有闭包的话只能是⾮逃逸闭包）

//如果将上面代码放到函数里面，就不会报错了
//放到函数里面，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种类型：

1. UnsafePointer<Pointee> 类似于 const Pointee *
2. UnsafeMutablePointer<Pointee> 类似于 Pointee *
3. UnsafeRawPointer 类似于 const void *
4. 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)
//获取指向堆空间实例的指针，更简单的⽅法