- 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(©OfStepSize)
// 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) // 正常
}
// 两个存储属性任何情况下都不会相互影响(全局变量，传指针，局部变量传值)
- 遵循下面原则，编译器可保证结构体属性的重叠访问安全
- 访问的是实例的存储属性，而非计算属性或类的属性
- 结构体是本地变量的值，而非全局变量
- 结构体要么没有被闭包捕获，要么只被非逃逸闭包捕获了
