Swift Memory Safty Swift 内存安全机理（乱译）

前言

乱译：不是规规矩矩的翻译，主要目的是为了学知识。但也是无奈之举，水平有限，我不会啊。有些地方我加入了自己的理解，关于新的知识点我会翻译的详细些，旧知识我就概括翻译，不懂的就不翻译。
官网 : Memory Safety

Beginning

默认情况下，Swift 会防止不安全的编码行为发生。例如：
1 .确保变量在初始化之后才能使用
2 .内存（对象）释放之后，是不可访问的
3 .数组下标会做越界检测

Swift 可以确保同一内存多个访问不发生冲突。是这样做到的：
把一个内存地址改到一个唯一的地址。啥，啥，啥！不会翻译，好像是说，每一个访问的代码在修改对象之前，都会修改访问对象的地址到一个只有它自己可以访问的唯一的地址。这样就不冲突了(后面发现它这是针对单线程的，一开始，误以为是多线程读到这吓一跳)

Swift 的这些内存管理都是自动的，如果我们的代码包含了冲突，会有编译时错误或运行时错误，但是我们应知其然知其所以然。这就是这篇文章的目的。

Understanding Conflicting Access to Memory 理解内存访问冲突

当我们给变量赋值或向函数传参时，就会发生内存访问。如下代码包含了内存读访问和写访问

// one 被写入内存
var one = 1
// one 从内存中读出来
print("We're number \(one)!")

下面举个了账单的读写冲突的例子，旧知识，老生常谈的，不翻译了，。。。

note
这里讨论的是单线程的情况，不包含并发编程和多线程情况。
如果你是在单线程时，写了内存访问冲突的代码，Swift会自动的在编译或运行时报错。
如果你多线程编程请使用 Thread Sanitizer 帮助你检测线程冲突。

Characteristics of Memory Access 内存访问的特征

相当于介绍了内存访问：问自己什么是内存访问，便于理解。

至少一个在读
多个同时写
他们期间，发生重叠。读的期间，写的期间。

想一想，有些读写是瞬间的有些并不是瞬间的，不能理解看完后面的部分，就会明白

访问有瞬间访问和长期访问之分，当然，瞬间访问是不会冲突。大部分内存访问都是瞬间访问，例如下面的例子

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

var myNumber = 1
myNumber = oneMore(than: myNumber)
print(myNumber)
// Prints "2"

但是，重点！重点！重点！有几种方式的内存访问是长期访问，在这个期间，其他代码可以执行。

和瞬间访问不同，对长期访问来说，其他代码是可以在长期访问开始但没有结束期间执行的。我们把这叫做 overlap 覆盖

长期访问最基本的一个例子是在使用 in-out 参数时。

Conflicting Access to In-Out Paramters In-Out 参数访问冲突

函数对它所有的 in-out 参数持有长期写的访问，持有开始于非 in-out 参数的 evaluated （啥啥啥，不会翻译了，就记住从函数开始到函数结束）（这是Swift语言决定的，我说的哈哈）

长期写访问的一个结论是 ：你不能访问通过 in-out 修饰传过来的参数，即使它本来可以访问。例如下面的例子，你一运行就 crash 报错： Simultaneous accesses to 0x100006728, but modification requires exclusive access.

var stepSize = 1

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

increment(&stepSize)
// Error: conflicting accesses to stepSize

虽然 stepSize is a global variable, 本来可以访问，但这里不能访问了！看下图很容易理解

1547091660951.jpg

一种解决方案是：对 setpSize 显示 copy

// Make an explicit copy.
var copyOfStepSize = stepSize
increment(&copyOfStepSize)

// Update the original.
stepSize = copyOfStepSize
// stepSize is now 2

长期写访问的另一个关于 in-out 参数的结论是：不可以对有多个 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)  // OK
balance(&playerOneScore, &playerOneScore)
// Error: conflicting accesses to playerOneScore

Conflicting Access to self in Methods 方法中 self 的访问冲突
结构体的可变方法在被调用期间对 self 持有读的访问。

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)  // OK

如果，你把 oscar 作为参数传给 sheareHealth(with:),会有冲突：

oscar.shareHealth(with: &oscar)
// Error: conflicting accesses to oscar

shareHealth 对 self 有读的访问，in-out 对 teammate 有读的访问。self 和 teammate 都是 oscar 产生冲突！这一点原文的图好像画的有点问题，文字表述是对的。

Conflicting Access to Properties 属性访问冲突
对于值类型像 structures,tuple,enumerations 他们是由单个的值组成。任何一个属性的修改，都会对整个值持有读或写的访问。例如下面会产生些访问冲突

var playerInformation = (health: 10, energy: 20)
balance(&playerInformation.health, &playerInformation.energy)
// Error: conflicting access to properties of playerInformation

同时持有 playerInfomation


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

同时持有 holly

但是在实际开发中，有时结构体属性的覆盖访问是安全的。如下例子:

func someFunction() {
    var oscar = Player(name: "Oscar", health: 10, energy: 10)
    balance(&oscar.health, &oscar.energy)  // OK
}

上面这个例子中，oscar 是局部变量 health 和 energy 这两个储属性没有在任何地方交互，所以编译器判断这个内存覆盖访问是安全的。

Memory safety 的目的是为了保证内存访问的安全，但是唯一访问的要求更加的严格。Swift 允许非唯一访问内存，只要它能够证明内存是安全的。
对于结构体，满足下面条件的就可以证明是安全的

你正在访问的的只有实例的存储属性，不包括计算属性和类属性
结构体是局部变量
结构体没有被闭包捕获，或者被非逃逸闭包捕获。（捕获就是放在闭包你面，我说的哈哈）

如果编译器不能证明访问是安全的，它就不允许访问，就会报错！