关于 Swift 4 中内存安全访问

本文主要翻译今年 The Swift Programming Language (Swift 4) 中新出的章节 -《Memory Safety》。在 Swift 4 中，内存安全访问进行很大的优化《What's New in Swift 4 ?》。

默认情况下，Swift 会克服代码层面上的一些不安全的行为，如：确保一个变量被初始化完后才能被访问、确保变量在销毁后不会被访问等等安全操作。

Swift 也会确保在�多路访问内存中同一区域时不会冲突（独占访问��该区域）。通常情况下，我们完全无需考虑内存访问�冲突的问题，因为 Swift 是自动管理内存的。然而，在�码代码的时候，了解那些地方可能发生内存访问冲突是非常重要的。通常情况下，如果你的代码有�内存访问冲突，那么 Xcode 会提示编译�错误或者运行时错误。

本文不会介绍什么是内存�访问冲突。详见 The Swift Programming Language (Swift 4)。如果你写的是并发或者多线程的程序，内存冲突访问与单线程是非常相似的一个问题。本文主要讨论�单线程上的内存冲突访问。如果想检测多线程是否存在内存访问冲突，你可以看看这篇文档。

我们可以把访问分为两种：即时和长期（instantaneous & long-term）

即时访问：即在访问开始至�结束前都不可能有其他�代码来�访问同一区域。
长期访问：即在访问开始至�结束前可能有其他代码来访问同一区域。��长期访问可能和其他即时访问或者长期�访问重叠。

重叠访问主要带有 in-out 参数的函数（或方法）以及结构体中带有 mutating 关键字的方法。我们下面来看看�例子。

In-Out 参数的访问冲突

�一个函数对其 in-out 参数具有长期的访问权限，如下代码：

Excerpt From: Apple Inc. "The Swift Programming Language (Swift 4).” iBooks".


var stepSize = 1
 
func increment(_ number: inout Int) {
    number += stepSize
}
 
increment(&stepSize)
// Error: conflicting accesses to stepSize

在上述代码中，stepSize 是一个全局变量，而且被作为一个 in-out 参数传给 increment(_:) 方法。冲突的原因在于 number 和 stepSize 引用的是�内存中同一区域，并且同时进行读写访问，因此导致访问冲突。

memory_increment_2x

我们可以�采用复制 stepSize 的方式解决该问题：


// Make an explicit copy.
var copyOfStepSize = stepSize
increment(©OfStepSize)
 
// Update the original.
stepSize = copyOfStepSize
// stepSize is now 2
// stepSize is now 2

�self 的访问冲突

在结构体中，带有 mutating 关键字的方法调用期间对 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

�上述代码是 Ok 的，�即时写入权限在时间上是重叠的，但是是分别访问 oscar 的 health 和 maria 的 health，因此在 shareHealth(with:) 方法中并没有发生内存访问冲突。

memory_share_health_maria_2x

然而，如果你把 oscar 作为参数传给 shareHealth(with:)，那么�就会产生内存访问冲突：


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

很显然，shareHealth(with:) 方法中的 �self 和 teammate 同时指向内存中同一区域，即同时对 oscar 的 health 进行读写访问，因此导致访问冲突。

memory_share_health_oscar_2x

属性的访问冲突

像结构体、�元组、枚举这些类型都是由各个值组成的，如：结构体的�各种属性、元组的各种元素等等。因为�它们都是值类型，这意味着对其中一个属性的读写访问就是对整个值进行读写访问。代码如下：


var playerInformation = (health: 10, energy: 20)

balance(&playerInformation.health, &playerInformation.energy)

// Error: conflicting access to properties of playerInformation

上述代码不难理解，因为元祖是值类型，上述 balance(_:_:) 发生内存访问冲突，即同时访问 playerInformation。

下面我们再看一下结构体，其中 holly 是一个全局变量


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

上述代码会报这样一个错误：Simultaneous accesses to 0x10****580, but modification requires exclusive access。�其实就是内存访问冲突了，Swift 4 中也针对这块做了优化处理，�感兴趣的同学可以�查阅我之前写的一篇文章《[WWDC17] What's New in Swift 4 ?》。

在实践中，上述代码中的 holly 一般是个局部变量而非全局变量，编译器可以保证对结构体的存储属性�进行重叠访问是安全的，代码如下：


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

上述代码�运行是 Ok 的，有时候，限制�结构体的各属性进行重叠访问是没有必要的，这也就是为什么 someFunction() 没有发生冲突访问的原因。内存访问安全虽应当得到保证，但是独占访问比内存�安全访问要求更加严格，从上述代码可看出，即时违背了独占访问的原则，内存安全也能得到保证。一般情况下，编译器会在如下条件下保证对结构体的存储属性�进行安全的重叠访问：

只访问某个实例的存储属性，而不是计算属性或类属性
访问的是�局部的结构体变量，而不是全局变量
结构体没有被任何闭包所捕获，或者仅被非逃逸闭包捕获。

感兴趣的同学可以查阅这里 The Swift Programming Language (Swift 4)。

关于 Swift 4 中内存安全访问

In-Out 参数的访问冲突

�self 的访问冲突

属性的访问冲突

你可能感兴趣的:(关于 Swift 4 中内存安全访问)