25、【Swift】内存安全

• Swift 安全性
  • 使用前就初始化
  • 内存在变量释放后不能再访问
  • 数组会检查越界错误
• Swift 还通过要求标记内存位置来确保代码对内存有独占访问权，以确保了同一内存多访问时不会冲突。
  • 了解一下什么情况下会潜在导致冲突
  • 避免写出对内存访问冲突的代码

理解内存访问冲突

• 出现场景：给变量赋值，或者传递参数给函数
• 比如说，下面代码同时包含了读取访问和写入访问：

// 向 one 所在的内存区域发起一次写操作
var one = 1

// 向 one 所在的内存区域发起一次读操作
print("We're number \(one)!")

• 添加预算项进入表里的时候，它只是在一个临时的，错误的状态，因为总数还没有被更新
• 在添加数据的过程中读取总数就会读取到错误的信息。

../_images/memory_shopping_2x.png

这里访问冲突的讨论是在单线程的情境下讨论的，并没有使用并发或者多线程。

在单线程遇到内存访问冲突，Swift 会保证你在要么编译时要么运行时得到错误。

对于多线程的代码，可以使用 Thread Sanitizer 去帮助检测多线程的冲突

内存访问性质

• 冲突会在两个访问，同时满足以下条件时发生：
  • 至少一个是写入访问；
  • 它们访问的是同一块内存；
  • 它们的访问时间重叠。
• 读和写访问的区别
  • 写访问会改变存储地址，而读操作不会（存储地址是指向正在访问的东西（例如一个变量，常量或者属性）的位置的值）
• 内存访问的时长要么是瞬时的，要么是长期的
• 瞬时访问：一个访问在启动后其他代码不能执行直到它结束后才能
• 两个即时访问不能同时发生
• 大多数内存访问都是即时

func oneMore(than number: Int) -> Int {
    return number + 1
}

var myNumber = 1
myNumber = oneMore(than: myNumber)
print(myNumber)
// 打印“2”

• 长期访问：会在别的代码执行时持续进行
  • 长期访问，可被别的长期访问、访问重叠
• 重叠访问场景
  • 使用 in-out 参数的函数和方法
  • 结构体的 mutating 方法里

In-Out 参数的访问冲突

• 冲突本质：一个函数会对它所有的 in-out 参数进行长期写访问
• 顺序：
  • 所有非 in-out 参数处理完之后开始，直到函数执行完毕为止
  • 有多个 in-out 参数，则写访问开始的顺序与参数的顺序一致
• 不能在访问以 in-out 形式传入后的原变量，即使作用域原则和访问权限允许

var stepSize = 1// 全局变量

func increment(_ number: inout Int) {
    number += stepSize //  stepSize 的读访问与 number 的写访问重叠了
}

increment(&stepSize)
// 错误：stepSize 访问冲突

• number 和 stepSize 都指向了同一个存储地址
• 同一块内存的读和写访问重叠了

image

• 解决 inout 参数访问冲突：拷贝一份 stepSize

// Make an explicit copy.
var copyOfStepSize = stepSize
increment(&copyOfStepSize)
 
// Update the original.
stepSize = copyOfStepSize
// stepSize is now 2
// stepSize is now 2

• 读访问在写操作之前就已经结束了，所以不会有冲突。

• 同一个函数的多个 in-out 参数里传入同一个变量，产生冲突

func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}
var playerOneScore = 42
var playerTwoScore = 30
balance(&playerOneScore, &playerTwoScore)  // 正常, 访问的是不同的内存位置
balance(&playerOneScore, &playerOneScore)// 同时访问同一个的存储地址。
// 错误：playerOneScore 访问冲突

操作符也是函数，也会对 in-out 参数进行长期访问

balance(_:_:) 是一个名为 <^> 的操作符函数，那么 playerOneScore <^> playerOneScore 也会造成像 balance(&playerOneScore, &playerOneScore) 一样的冲突

方法里 self 的访问冲突

• 本质：结构体的 mutating 方法会在调用期间对 self 进行写访问

struct Player {
    var name: String
    var health: Int
    var energy: Int

    static let maxHealth = 10
    mutating func restoreHealth() {
        health = Player.maxHealth
    }
}

• 不管有没有调用 self，只要 标记了mutating

  • 在上面的 restoreHealth() 方法里，一个对于 self 的写访问会从方法开始直到方法 return
  • 不可以对 Player 实例的属性发起重叠的访问

• shareHealth(with:) 接受另一个 Player 的实例作为 in-out 参数，有访问重叠的可能性

extension Player {
    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 玩家的血量分享给 maria 玩家
  • 方法调用时会对 oscar 发起写访问，在 mutating 方法里 self 就是 oscar
  • maria 也会发起写访问，因为 maria 作为 in-out 参数传入
  • 访问内存的不同位置。即使两个写访问重叠了，它们也不会冲突

img

oscar.shareHealth(with: &oscar)
// 错误：oscar 访问冲突

• self 和 teammate 都指向了同一个存储地址
• 同一块内存同时进行两个写访问，并且它们重叠了，就此产生了冲突

image

oscar.shareHealth(with: &oscar)
// 错误：oscar 访问冲突

• self 和 teammate 都指向了同一个存储地址
• 同一块内存同时进行两个写访问，并且它们重叠了，就此产生了冲突

image

属性的访问冲突

• 出现场景：
  • 值类型：结构体，元组和枚举，由多个独立的值组成
  • 修改值的一部分都是对整个值的修改
  • 一个属性的读或写访问都需要访问整一个值
• 如，元组元素的写访问重叠会产生冲突：

var playerInformation = (health: 10, energy: 20)
balance(&playerInformation.health, &playerInformation.energy)
// 错误：playerInformation 的属性访问冲突

• 传入同一元组的元素对 balance(_:_:) 进行调用，产生了冲突，因为 playerInformation 的访问产生了写访问重叠
• 作为 in-out 参数传入
• 对于元组元素的写访问都需要对整个元组发起写访问

• 展示错误：对于一个存储在全局变量里的结构体属性的写访问重叠 (struct Player)

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

• 解决：将变量 holly 改为本地变量，而非全局变量，

func someFunction() {
    var oscar = Player(name: "Oscar", health: 10, energy: 10)
    balance(&oscar.health, &oscar.energy)  // 正常
}
// 两个存储属性任何情况下都不会相互影响(全局变量，传指针，局部变量传值)

• 遵循下面原则，编译器可保证结构体属性的重叠访问安全
  • 访问的是实例的存储属性，而非计算属性或类的属性
  • 结构体是本地变量的值，而非全局变量
  • 结构体要么没有被闭包捕获，要么只被非逃逸闭包捕获了