案例代码下载

内存安全

默认情况下，Swift可以防止代码中发生不安全行为。例如，Swift确保变量在使用之前进行初始化，在取消分配后不访问内存，并检查数组索引是否存在越界错误。

Swift还确保对同一内存区域的多次访问不会发生冲突，因为需要修改内存中某个位置的代码才能对该内存进行独占访问。因为Swift自动管理内存，所以大多数时候根本不需要考虑访问内存。但是，了解潜在冲突可能发生的位置非常重要，这样就可以避免编写对内存具有冲突访问权限的代码。如果代码确实包含冲突，那么将收到编译时或运行时错误。

了解对内存的冲突访问

当执行诸如设置变量的值或将参数传递给函数之类的操作时，会在代码中访问内存。例如，以下代码包含读写内存：

var one = 1
print("We're number \(one)!")

/*
打印结果：

We're number 1!
*/

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

通过考虑如何更新写在纸上的预算，可以看到类似的问题。更新预算的过程分为两步：首先添加项目的名称和价格，然后更改总金额以反映列表中当前的项目。在更新之前和之后，可以从预算中读取任何信息并获得正确答案，如下图所示。

image

当在预算中添加项目时，它处于临时无效状态，因为总金额尚未更新以反映新添加的项目。在添加项目的过程中读取总金额会导致不正确的信息。

此示例还演示了在修复对内存的冲突访问时可能遇到的挑战：有时有多种方法可以解决产生不同答案的冲突，并且并不总是很明显哪个答案是正确的。在此示例中，根据是否需要原始总金额或更新的总金额， 320可能是正确的答案。在修复冲突访问之前，必须确定要执行的操作。

注意

如果编写了并发或多线程代码，则对内存的冲突访问可能是一个熟悉的问题。但是，此处讨论的冲突访问可能发生在单个线程上，并且不涉及并发或多线程代码。

如果在单个线程中存在对内存的冲突访问，Swift会保证您在编译时或运行时都会收到错误。对于多线程代码，请使用Thread Sanitizer来帮助检测跨线程的冲突访问。

内存访问的特征

在冲突访问的上下文中要考虑存储器访问的三个特征：访问是读取还是写入，访问的持续时间以及访问的存储器中的位置。具体而言，如果有两个满足以下所有条件的访问，则会发生冲突：

• 至少一个是写访问。
• 他们访问内存中的相同位置。
• 他们的持续时间重叠。

读写访问之间的区别通常很明显：写访问会更改内存中的位置，但读访问不会。内存中的位置是指正在访问的内容 - 例如，变量，常量或属性。存储器访问的持续时间是瞬时的或长期的。

如果在访问开始之后但在结束之前其他代码无法运行，则访问是即时的。就其本质而言，两次即时访问不可能同时发生。大多数内存访问都是即时的。例如，下面代码清单中的所有读写访问都是即时的：

func oneMore(than number: Int) -> Int {
    return number + 1
}
var myNumber = 1
myNumber = oneMore(than: myNumber)
print(myNumber)

/*
打印结果：

2
*/

但是，有几种方法可以访问内存，称为长期访问，跨越其他代码的执行。即时访问和长期访问之间的区别在于，其他代码可以在长期访问开始之后但在结束之前运行，这称为重叠。长期访问可以与其他长期访问和即时访问重叠。

重叠访问主要出现在使用函数和方法中的输入输出参数或结构的mutating方法的代码中。使用长期访问的特定Swift代码类型将在下面的部分中讨论。

对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在存储器中指代相同的位置。读和写访问指的是相同的内存，它们重叠，产生冲突。

image

解决这种冲突的一种方法是制作一份明确的副本stepSize：

var copyOfStepSize = stepSize // 制作一个副本
increment(&copyOfStepSize)
stepSize = copyOfStepSize

当stepSize在increment(_:)调用之前复制，很明显，copyOfStepSize的值通过当前的stepSize增加。读访问在写访问开始之前结束，因此不存在冲突。

对输入输出参数进行长期写访问的另一个后果是，将单个变量作为同一函数的多个输入输出参数的参数传递会产生冲突。例如：

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

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

注意

因为运算符是函数，所以它们也可以长期访问其输入输出参数。例如，如果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
    }
}

在上面的restoreHealth()方法中，self写入访问从方法的开头开始并持续到方法返回。在这种情况下，内部没有其他restoreHealth()代码可以重叠访问Player实例的属性。下面的shareHealth(with:)方法将另一个Player实例作为输入输出参数，从而创建重叠访问的可能性。

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游戏者的shareHealth(with:)方法与Maria共享健康状态不会导致冲突。在方法调用期间对oscar存在写访问权，因为oscar是的mutating方法中self的值，并且maria在相同的持续时间内存在写访问权，因为它maria是作为输入输出参数传递的。如下图所示，它们访问内存中的不同位置。即使两个写访问在时间上重叠，它们也不会发生冲突。

image

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

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

mutating方法需要在方法的持续时间内对self进行写访问，并且需要对输入输出参数teammate相同持续时间的写访问权。在该方法中，无论是self和teammate指的是相同的位置在内存如示于下图中。两次写访问指的是相同的内存，它们重叠，产生冲突。

image

对属性的冲突访问

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

var playerInformation = (health: 10, enertgy: 10)
balance(&playerInformation.health, &playerInformation.enertgy) // 错误：冲突访问playerInformation

在上面的示例中，调用balance(::)元组的元素会产生冲突，因为存在重叠的playerInformation写访问。playerInformation.health和playerInformation.energy双方都在出参数，这意味着调用balance(::)函数的持续时间需要写访问。在这两种情况下，对元组元素的写访问都需要对整个元组进行写访问。这意味着有两次写访问playerInformation，持续时间重叠，导致冲突。

下面显示的代码，对于存储在全局变量中的结构属性的重写写访问，会出现相同的错误。

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) // 可以
}
someFunction()

在上面的例子中，oscar的健康和能量作为两个in-out参数传递给balance(::)。编译器可以证明保留了内存安全性，因为两个存储的属性不会以任何方式进行交互。

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

• 只访问实例的存储属性，而不是计算属性或类属性。
• 结构是局部变量的值，而不是全局变量。
• 结构要么不被任何闭包捕获，要么仅由非逃逸闭包捕获。

如果编译器无法证明访问是安全的，则不允许访问。