Swift-内存安全

• 默认情况下，Swift 会阻止你代码里不安全的行为。
• 例如：
  • Swift 会保证变量在使用之前就完成初始化，在内存被回收之后就无法被访问
  • 并且数组的索引会做越界检查。
• Swift 也保证同时访问同一块内存时不会冲突，通过约束代码里对于存储地址的写操作，去获取那一块内存的访问独占权。
• 因为 Swift 自动管理内存，所以大部分时候你完全不需要考虑内存访问的事情。
• 然而，理解潜在的冲突也是很重要的，可以避免你写出访问冲突的代码。
• 如果你的代码确实存在冲突，那在编译时或者运行时就会得到错误。

1. 理解内存访问冲突

• 内存的访问，会发生在你给变量赋值，或者传递参数给函数时。
• 下面的代码就包含了读和写的访问：

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

注意：
	1. 内存访问的冲突会发生在你的代码尝试同时访问同一个存储地址的时侯。
	2. 同一个存储地址的多个访问同时发生会造成不可预计或不一致的行为。
	3. 在 Swift 里，有很多修改值的行为都会持续好几行代码，在修改值的过程中进行访问是有可能发生的。

1. 可以思考一下预算表更新的过程，会看到同样的问题。
2. 更新预算表总共有两步：首先你把预算项的名字和费用加上，然后再更新总数来反映预算表的现况。
3. 在更新之前和之后，你都可以从预算表里读取任何信息并获得正确的答案，就像下面展示的那样。
4. 而当你添加预算项进入表里的时候，它只是在一个临时的，错误的状态，因为总数还没有被更新。
5. 在添加数据的过程中读取总数就会读取到错误的信息。

注意：
	1. 如果你写过并发和多线程的代码，内存访问冲突也许是同样的问题。
	2. 然而，这里访问冲突的讨论是在单线程的情境下讨论的，并没有使用并发或者多线程。
	3. 如果你曾经在单线程代码里有访问冲突，Swift 可以保证你在编译或者运行时会得到错误。对于多线程的代码，可以使用 Thread Sanitizer 去帮助检测多线程的冲突。

1.1 内存访问性质

• 内存访问冲突时，要考虑内存访问上下文中的这三个性质：
  • 访问是读还是写
  • 访问的时长
  • 被访问的存储地址。
• 特别是，冲突会发生在当你有两个访问符合下列的情况：
  • 至少有一个是写访问
  • 它们访问的是同一个存储地址
  • 它们的访问在时间线上部分重叠
• 读和写访问的区别很明显：
  • 一个写访问会改变存储地址，而读操作不会。
  • 存储地址是指向正在访问的东西（例如一个变量，常量或者属性）的位置的值 。
  • 内存访问的时长要么是瞬时的，要么是长期的。
• 如果一个访问不可能在其访问期间被其它代码访问，那么就是一个瞬时访问。正常来说，两个瞬时访问是不可能同时发生的。大多数内存访问都是瞬时的。
• 例如，下面列举的所有读和写访问都是瞬时的：

func oneMore(than number: Int) -> Int {
    return number + 1
}
​
var myNumber = 1
myNumber = oneMore(than: myNumber)
print(myNumber)		// 打印“2”

有几种被称为长期访问的内存访问方式，会在别的代码执行时持续进行。
瞬时访问和长期访问的区别在于别的代码有没有可能在访问期间同时访问，也就是在时间线上的重叠。
一个长期访问可以被别的长期访问或瞬时访问重叠。

• 重叠的访问主要出现在使用 in-out 参数的函数和方法或者结构体的 mutating 方法里。

2. In-Out 参数的访问冲突

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

var stepSize = 1
​
func increment(_ number: inout Int) {
    number += stepSize
}
​
increment(&stepSize)
// 错误：stepSize 访问冲突

在上面的代码里，stepSize 是一个全局变量，并且它可以在 increment(_? 里正常访问。
然而，对于 stepSize 的读访问与 number 的写访问重叠了。

• 像下面展示的那样，number 和 stepSize 都指向了同一个存储地址。同一块内存的读和写访问重叠了，就此产生了冲突。

func increment(_ number : inout Int){
	number += stepSize
}

• 解决这个冲突的一种方式，是显示拷贝一份 stepSize ：

// 显式拷贝
var copyOfStepSize = stepSize
increment(&copyOfStepSize)
​
// 更新原来的值
stepSize = copyOfStepSize
// stepSize 现在的值是 2

当你在调用 increment(_? 之前做一份拷贝，显然 copyOfStepSize 就会根据当前的 stepSize 增加。读访问在写操作之前就已经结束了，所以不会有冲突。

• 长期写访问的存在还会造成另一种结果，往同一个函数的多个 in-out 参数里传入同一个变量也会产生冲突，例如：

func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum -