默认情况下，Swift可以防止代码中出现不安全行为。例如，Swift确保变量在使用之前被初始化，内存在被释放后不被访问，数组索引被检查是否越界。
Swift还确保对同一内存区域的多次访问不会发生冲突，这是因为只有需要修改内存中某个位置的代码才拥有对该内存的访问权限。因为Swift是自动管理内存的，通常情况下根本不需要考虑访问内存。但是，了解潜在冲突可能发生在哪里是很重要的，这样可以避免编写访问内存的冲突代码。如果代码中确实包含冲突，则在编译或运行时发生错误。

一、内存访问冲突

当执行诸如设置变量值或向函数传递参数等操作时，就会在代码中发生对内存的访问。例如，以下代码包含读访问和写访问:

// A write access to the memory where one is stored.
var one = 1

// A read access from the memory where one is stored.
print("We're number \(one)!")

当代码的不同部分试图同时访问内存中的相同位置时，可能会发生内存访问冲突。同时多次访问内存中的某个位置会产生不可预测或不一致的行为。在Swift中，有一些方法可以修改一个跨越多行代码的值，从而可以尝试在自己的修改过程中访问一个值。

memory_shopping_2x.png

这个例子还演示了在修复内存的访问冲突时可能遇到的一个挑战:有时有多种方法可以解决冲突，同时也产生不同的答案，而且无法确定哪个答案是正确的。在本例中，根据您想要原始的总额还是更新后的总额，5美元或320美元可能是正确的答案。在修复冲突访问之前，你必须确定要执行的操作。

注意：如果你编写过并发或多线程代码，则对内存的冲突访问可能是一个熟悉的问题。但是，此处讨论的冲突访问可能发生在单个线程上，并且不涉及并发或多线程代码。
如果在单线程中存在内存访问冲突，Swift会保证在编译时或运行时都会收到错误。对于多线程代码，请使用Thread Sanitizer帮助检测跨线程的冲突访问。

二、内存访问的特征

在冲突访问的上下文中，需要考虑内存访问的三个特征:访问是读还是写，访问的持续时间，以及在内存中的访问位置。具体来说，如果您有两个满足以下所有条件的访问，就会发生冲突:

• 至少有一个是写访问。
• 它们访问内存中的相同位置。
• 它们的时间重叠。
  读访问和写访问之间的区别通常很明显:写访问改变内存中的位置，但读访问不会。内存中的位置是指正在访问的内容 - 例如，变量，常量或属性。内存访问的持续时间可以是瞬时的，也可以是长期的。
  如果在访问开始之后但在访问结束之前不能运行其他代码，则访问是瞬时的。从本质上讲，两次瞬时访问不可能同时发生。大多数内存访问是瞬时的。例如，下面代码清单中的所有读写访问都是瞬时的:

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

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

但是，有几种访问内存的方法，称为长期访问，可以跨越其他代码的执行。瞬时访问和长期访问的区别在于，其他代码可以在长期访问开始后结束之前运行，这称为重叠。长期访问可以与其他长期访问和瞬时访问重叠。
重叠访问主要出现在在函数和方法中使用in-out参数的代码中，或者是结构体的可变方法中。使用长期访问的特定Swift代码类型将在下面的部分中讨论。

三、对In-Out参数的访问冲突

函数拥有对其所有in-out参数的长期写访问权。一个in-out参数的写访问在所有非in-out参数被计算之后开始，并持续到整个函数调用期间。如果有多个in-out参数，则写访问的开始顺序与参数出现的顺序相同。
这种长期写访问的一个后果是，您不能访问作为in-out传递的原始变量，即使范围规则和访问控制允许这样做——任何对原始变量的访问都会产生冲突。例如:

var stepSize = 1

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

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

在上面的代码中，stepSize是一个全局变量，通常可以从increment(_:)访问它。但是，对stepSize的读访问与对number的写访问重叠。如下图所示，number和stepSize都指向内存中的同一个位置。读和写访问引用相同的内存，它们重叠，产生冲突。

memory_increment_2x.png

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

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

当在调用increment(_:)之前复制一个stepSize时，很明显copyOfStepSize的值是由当前stepSize递增的。读访问在写访问开始之前结束，所以没有冲突。
对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

上面balance(_:_:)函数修改了它的两个参数，使它们之间的值相等。用playerOneScore和playerTwoScore调用它不会产生冲突——有两个写访问在时间上重叠，但它们访问的是不同的内存位置。相反，将playerOneScore作为两个参数的值传递会产生冲突，因为它试图同时执行对内存中相同位置的两次写访问。

注意：由于操作符是函数，它们也可以长期访问它们的in-out参数。
因为运算符是函数，所以它们也可以长期访问其in-out参数。例如，如果balance(_:_:)是一个名为<^>的运算符函数，则写入playerOneScore <^> playerOneScore将导致与balance(&playerOneScore, &playerOneScore)相同的冲突。

四、方法中self的访问冲突

结构体上的可变方法在方法调用期间对self具有写访问权。例如，考虑这样一个游戏，每个玩家都有一个生命值(在受到伤害时减少)和一个能量值(在使用特殊技能时减少)。

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

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

在上面的restoreHealth()方法中，对self的写访问从方法的开头开始，一直持续到方法返回为止。在本例中，restoreHealth()中没有其他代码可以重叠访问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)  // OK

在上面的例子中，调用Oscar玩家的shareHealth(with:)方法与Maria 玩家共享生命值不会引起冲突。在方法调用期间有对oscar的写访问，因为oscar是可变方法中的self值，在相同的时间内也有对maria的写访问，因为maria是作为 in-out参数传递的。如下图所示，它们访问内存中的不同位置。尽管两个写访问在时间上是重叠的，但它们并不冲突。

memory_share_health_maria_2x.png

但是，如果将oscar作为参数传递给shareHealth(with:)，则存在冲突：

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

在该方法的持续时间内，可变方法需要对self的写访问。而在相同的持续时间内，in-out参数需要对teammate的写访问。在方法中，self和teamate引用内存中的相同位置—如下图所示。这两个写访问引用相同的内存，它们重叠，产生冲突。

memory_share_health_oscar_2x.png

五、属性的访问冲突

结构体、元组和枚举等类型由单个组成值组成，例如结构体的属性或元组的元素。由于这些都是值类型，因此改变值的任何部分会改变整个值，这意味着对其中一个属性的读或写访问需要对整个值进行读或写访问。例如，对元组元素的重叠写访问会产生冲突:

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

在上面的例子中，调用元组元素上的balance(_:_:)会产生冲突，因为对playerInformation的写访问有重叠。playerInformation.health和playerInformation.energy作为in-out参数传递，这意味着balance(_:_:)在函数调用期间需要对它们进行写访问。在这两种情况下，对tuple元素的写访问都需要对整个tuple进行写访问。这意味着有两个对playerInformation的写访问，它们的持续时间重叠，导致冲突。
下面的代码显示，对存储在全局变量中的结构体属性的重叠写访问，会出现相同的错误。

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 作为两个输入参数传递给balance(_:_:)。编译器可以证明保留了内存安全性，因为这两个存储属性不以任何方式交互。

反对重叠访问结构体属性的限制并不总是保证内存安全的必要条件。内存安全是理想的保证，但唯一的访问是比内存安全更严格的要求 - 这意味着一些代码可以维护内存安全，即使它违反了对内存的唯一访问权限。如果编译器可以证明对内存的非单独访问仍然是安全的，那么Swift允许这种内存安全的代码。具体而言，如果满足以下条件，则可以证明对结构属性的重叠访问是安全的：

• 只访问实例的存储属性，而不是计算属性或类属性。
• 结构体是局部变量的值，而不是全局变量。
• 该结构体要么不被任何闭包捕获，要么仅由非逃离闭包捕获。
  如果编译器无法证明访问是安全的，则不允许访问。

六、其他专题模块

Swift 4.2 基础专题详解