目录

  1. 前言
  2. In-Out 参数的访问冲突
  3. self 的访问冲突
  4. 属性的访问冲突
  5. 广告

前言

本文主要翻译今年 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”.

1
2
3
4
5
6
7
8
9

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 的方式解决该问题：

1
2
3
4
5
6
7
8
9

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

self 的访问冲突

在结构体中，带有 mutating 关键字的方法调用期间对 self 具有写入权限。

1
2
3
4
5
6
7
8
9
10
11
12

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:)，那么就会产生内存访问冲突：

1
2
3

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

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

memory_share_health_oscar_2x

属性的访问冲突

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

1
2
3
4
5
6

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

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

// Error: conflicting access to properties of playerInformation

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

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

1
2
3

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 一般是个局部变量而非全局变量，编译器可以保证对结构体的存储属性进行重叠访问是安全的，代码如下：

1
2
3
4
5

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)。

广告

欢迎关注微信公众号

wechat-qrcode