Swift 进阶（十三）内存管理

内存管理

基本概念

跟OC一样，Swift也是采取基于引用计数的ARC内存管理方案（针对堆空间）

Swift的ARC中有三种引用

强引用（strong reference）： 默认情况下，引用都是强引用

class Person { }
var po: Person?

弱引用（weak reference）：通过weak定义弱引用

class Person { }
weak var po: Person?

必须是可选类型的var，因为实例销毁后，ARC会自动将弱引用设置为nil

ARC自动给弱引用设置nil时，不会触发属性观察器

无主引用（unowned reference）： 通过unowned定义无主引用

不会产生强引用，实例销毁后仍然存储着实例的内存地址（类似于OC中的unsafe_unretained）

class Person { }
unowned var po: Person?

试图在实例销毁后访问无主引用，会产生运行时错误（野指针）

weak、unowned的使用限制

weak、unowned只能用在类实例上面

只有类是存放在堆空间的，堆空间的内存是需要我们手动管理的

protocol Liveable: AnyObject { }
class Person { }

weak var po: Person?
weak var p1: AnyObject?
weak var p2: Liveable?

unowned var p10: Person?
unowned var p11: AnyObject?
unowned var p12: Liveable?

Autoreleasepool

class Person {
    var age: Int
    var name: String
    
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    
    func run() {}
}

autoreleasepool {
    let p = Person(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引用，解决循环引用问题

func test() {
    let p = Person()
    p.fn = {
        [weak p] in
        p?.run()
    }
}

func test() {
    let p = Person()
    p.fn = {
        [unowned p] in
        p.run()
    }
}

如果想在定义闭包属性的同时引用self，这个闭包必须是lazy的（因为在实例初始化完毕之后才能引用self）

class Person {
    lazy var fn: (() -> ()) = {
        [weak self] in
        self?.run()
    }
    
    func run() { print("run") }
    deinit { print("deinit") }
}

闭包fn内部如果用到了实例成员（属性、方法），编译器会强制要求明确写出self

如果lazy属性是闭包调用的结果，那么不用考虑循环引用的问题（因为闭包调用后，闭包的生命周期就结束了）

class Person {
    var age: Int = 0
    lazy var getAge: Int = {
        self.age
    }()

    deinit { print("deinit") }
}

@escaping

非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数

非逃逸闭包：闭包调用发生在函数结束前，闭包调用在函数作用域内

typealias Fn = () -> ()

func test1(_ fn: Fn) { fn() }

逃逸闭包：闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping声明

typealias Fn = () -> ()

var gFn: Fn?
func test2(_ fn: @escaping Fn) { gFn = fn }

DispatchQueue.global().async也是一个逃逸闭包

使用示例如下

import Dispatch
typealias 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()
        }
    }
}

逃逸闭包不可以捕获inout参数

看下面的示例

如果逃逸闭包里捕获的是外面的局部变量的地址值，就会有局部变量已经不存在了之后才会执行逃逸闭包的情况，那么捕获的值就是不合理的

而非逃逸闭包是可以保证在局部变量的生命周期没有结束的时候就能够执行闭包的

内存访问冲突（Conflicting Access to Memory）

内存访问冲突会在两个访问满足下列条件时发生：

• 至少一个是写入操作
• 它们访问的是同一个内存
• 它们的访问时间重叠（比如在同一个函数内）

1.看下面示例，哪个会造成内存访问冲突

func plus(_ num: inout Int) -> Int { num + 1 }

var number = 1
number = plus(&number)

var step = 1
func increment(_ num: inout Int) { num += step }
increment(&step)

第一个不会造成内存访问冲突，第二个会造成内存访问冲突，并报错

因为在num += step中既访问了step的值，同时又进行了写入操作

解决方案如下

var step = 1
func increment(_ num: inout Int) { num += step }

var copyOfStep = step
increment(&copyOfStep)
step = copyOfStep

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

第一句执行不会报错，因为传进去的是两个变量的地址值，不会冲突

第二句会报错，传进去的都是同一个变量的地址值，而内部又同时进行了对num1的读写操作，所以会造成内存访问冲突

而且都不用运行，编译器直接就报错

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)
oscar.shareHealth(with: &oscar)

第一句执行不会报错，第二句执行会报错

因为传入的地址都是同一个，会造成内存访问冲突，而且也是在编译阶段就直接报错了

4.看下面示例，哪个会造成内存访问冲突

var tuple = (health: 10, energy: 20)

balance(&tuple.health, &tuple.energy)

var holly = Player(name: "Holly", health: 10, energy: 10)
balance(&holly.health, &holly.energy)

这两个都会报错，都是操作了同一个存储空间，同时进行了读写操作

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

• 你只访问实例存储属性，不是计算属性或者类属性
• 结构体是局部变量而非全局变量
• 结构体要么没有被闭包捕获，要么只被非逃逸闭包捕获

func test() {
    var tuple = (health: 10, energy: 20)
    balance(&tuple.health, &tuple.energy)
    
    var holly = Player(name: "Holly", health: 10, energy: 10)
    balance(&holly.health, &holly.energy)
}

test()

指针

Swift中也有专门的指针类型，这些都被定性为“Unsafe“（不安全的）， 常见的有以下四种类型

• UnsafePointer<Pointee>: 类似于const Pointee *
• UnsafeMutablePointer<Pointee>: 类似于Pointee *
• UnsafeRawPointer: 类似于const void *
• UnsafeMutableRawPointer: 类似于void *

UnsafePointer、UnsafeMutablePointer

var age = 10

func test1(_ ptr: UnsafeMutablePointer<Int>) {
    ptr.pointee += 10
}

func test2(_ ptr: UnsafePointer<Int>) {
    print(ptr.pointee)
}

test1(&age)
test2(&age) // 20
print(age) // 20

UnsafeRawPointer、UnsafeMutableRawPointer

var age = 10 

func test3(_ ptr: UnsafeMutableRawPointer) {
    ptr.storeBytes(of: 30, as: Int.self)
}

func test4(_ ptr: UnsafeRawPointer) {
    print(ptr.load(as: Int.self))
}

test3(&age)
test4(&age) // 30
print(age) // 30

NSArray的遍历方法中也使用了指针类型

var arr = NSArray(objects: 11, 22, 33, 44)
arr.enumerateObjects { (obj, idx, stop) in
    print(idx, obj)
    
    if idx == 2 { // 下标为2就停止遍历
        stop.pointee = true
    }
    
    print("----")
}

//0 11
//----
//1 22
//----
//2 33
//----

arr.enumerateObjects中的stop并不等同于break的作用，设置完stop也会继续执行完作用域中的代码，然后才会判断是否需要下一次循环

在Swift中遍历元素更适用于enumerated的方式

var arr = NSArray(objects: 11, 22, 33, 44)
for (idx, obj) in arr.enumerated() {
    print(idx, obj)
    if idx == 2 { break }
}

获得指向某个变量的指针

我们可以调用withUnsafeMutablePointer、withUnsafePointer来获得指向变量的指针

var age = 11
var ptr1 = withUnsafeMutablePointer(to: &age) { $0 }
var ptr2 = withUnsafePointer(to: &age) { $0 }
ptr1.pointee = 22

print(ptr2.pointee) // 22
print(age) // 22

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

withUnsafeMutablePointer的实现本质就是将传入的变量地址值放到闭包表达式中作为返回值

func withUnsafeMutablePointer<Result, T>(to value: inout T, _ body: (UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result {
    try body(&value)
}

获得指向堆空间实例的指针

class Person {}
var person = Person()

// ptr中存储的还是person指针变量的地址值
var ptr = withUnsafePointer(to: &person) { UnsafeRawPointer($0) }
// 从指针变量里取8个字节，也就是取出存储的堆空间地址值
var heapPtr = UnsafeRawPointer(bitPattern: ptr.load(as: UInt.self))
print(heapPtr!)

创建指针

第一种方式

var ptr = UnsafeRawPointer(bitPattern: 0x100001234)

第二种方式

// 创建
var ptr = malloc(16)

// 存
ptr?.storeBytes(of: 11, as: Int.self)
ptr?.storeBytes(of: 22, toByteOffset: 8, as: Int.self)

// 取
print(ptr?.load(as: Int.self)) // 11
print(ptr?.load(fromByteOffset: 8, as: Int.self)) // 22

// 销毁
free(ptr)

第三种方式

var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)

// 从前8个字节开始存储11
ptr.storeBytes(of: 11, as: Int.self)
// 指向后8个字节开始存储22
ptr.advanced(by: 8).storeBytes(of: 22, as: Int.self)

print(ptr.load(as: Int.self)) // 11
print(ptr.advanced(by: 8).load(as: Int.self)) // 22
ptr.deallocate()

第四种方式

var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 3)

// 先初始化内存
ptr.initialize(to: 11)
// ptr.successor表示下一个Int，也就是跳一个类型字节大小
ptr.successor().initialize(to: 22)
ptr.successor().successor().initialize(to: 33)

print(ptr.pointee) // 11

// ptr + 1，意味着跳过一个Int类型大小的字节数
print((ptr + 1).pointee) // 22
print((ptr + 2).pointee) // 33

print(ptr[0]) // 11
print(ptr[1]) // 22
print(ptr[2]) // 33

// 释放要调用反初始化，调用了几个就释放几个
ptr.deinitialize(count: 3)
ptr.deallocate()

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"))

ptr.deinitialize(count: 3)
ptr.deallocate()

指针之间的转换

var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
// 假想一个类型
ptr.assumingMemoryBound(to: Int.self)
// 不确定类型的pointer+8是真的加8个字节，不同于有类型的pointer
(ptr + 8).assumingMemoryBound(to: Double.self).pointee = 22.0

// 强制转换类型为Int
print(unsafeBitCast(ptr, to: UnsafePointer<Int>.self).pointee) // 11
print(unsafeBitCast((ptr + 8), to: UnsafePointer<Double>.self).pointee) // 22.0

ptr.deallocate()

unsafeBitCast是忽略数据类型的强制转换，不会因为数据类型的变化而改变原来的内存数据，所以这种转换也是不安全的

类似于C++中的reinterpret_cast

我们可以用unsafeBitCast的强制转换指针类型，直接将person变量里存储的堆空间地址值拷贝到ptr指针变量中，由于ptr是指针类型，那么它所指向的地址值就是堆空间地址

class Person {}
var person = Person()
var ptr = unsafeBitCast(person, to: UnsafeRawPointer.self)
print(ptr)

另一个转换方式，可以先转成UInt类型的变量，然后再从变量中取出存储的地址值

class Person {}
var person = Person()
var address = unsafeBitCast(person, to: UInt.self)
var ptr = UnsafeRawPointer(bitPattern: address)

看下面的示例

Int和Double的内存结构应该是有差异的，但通过unsafeBitCast转换的age3的内存结构和age1是一样的，所以说unsafeBitCast只会转换数据类型，不会改变内存数据