內(nèi)存安全

默認(rèn)情況下，Swift 會阻止你代碼里不安全的行為。例如，Swift 會保證變量在使用之前就完成初始化，在內(nèi)存被回收之后就無法被訪問，并且數(shù)組的索引會做越界檢查。

Swift 也保證同時訪問同一塊內(nèi)存時不會沖突，通過約束代碼里對于存儲地址的寫操作，去獲取那一塊內(nèi)存的訪問獨(dú)占權(quán)。因?yàn)?Swift 自動管理內(nèi)存，所以大部分時候你完全不需要考慮內(nèi)存訪問的事情。然而，理解潛在的沖突也是很重要的，可以避免你寫出訪問沖突的代碼。而如果你的代碼確實(shí)存在沖突，那在編譯時或者運(yùn)行時就會得到錯誤。

理解內(nèi)存訪問沖突

內(nèi)存的訪問，會發(fā)生在你給變量賦值，或者傳遞參數(shù)給函數(shù)時。例如，下面的代碼就包含了讀和寫的訪問：

// 向 one 所在的內(nèi)存區(qū)域發(fā)起一次寫操作
var one = 1

// 向 one 所在的內(nèi)存區(qū)域發(fā)起一次讀操作
print("We're number \(one)!")

內(nèi)存訪問的沖突會發(fā)生在你的代碼嘗試同時訪問同一個存儲地址的時侯。同一個存儲地址的多個訪問同時發(fā)生會造成不可預(yù)計或不一致的行為。在 Swift 里，有很多修改值的行為都會持續(xù)好幾行代碼，在修改值的過程中進(jìn)行訪問是有可能發(fā)生的。

你可以思考一下預(yù)算表更新的過程，會看到同樣的問題。更新預(yù)算表總共有兩步：首先你把預(yù)算項的名字和費(fèi)用加上，然后再更新總數(shù)來反映預(yù)算表的現(xiàn)況。在更新之前和之后，你都可以從預(yù)算表里讀取任何信息并獲得正確的答案，就像下面展示的那樣。

而當(dāng)你添加預(yù)算項進(jìn)入表里的時候，它只是在一個臨時的，錯誤的狀態(tài)，因?yàn)榭倲?shù)還沒有被更新。在添加數(shù)據(jù)的過程中讀取總數(shù)就會讀取到錯誤的信息。

這個例子也演示了你在修復(fù)內(nèi)存訪問沖突時會遇到的問題：有時修復(fù)的方式會有很多種，但哪一種是正確的就不總是那么明顯了。在這個例子里，根據(jù)你是否需要更新后的總數(shù)，$5 和 $320 都可能是正確的值。在你修復(fù)訪問沖突之前，你需要決定它的傾向。

注意

如果你寫過并發(fā)和多線程的代碼，內(nèi)存訪問沖突也許是同樣的問題。然而，這里訪問沖突的討論是在單線程的情境下討論的，并沒有使用并發(fā)或者多線程。

如果你曾經(jīng)在單線程代碼里有訪問沖突，Swift 可以保證你在編譯或者運(yùn)行時會得到錯誤。對于多線程的代碼，可以使用 Thread Sanitizer 去幫助檢測多線程的沖突。

內(nèi)存訪問性質(zhì)

內(nèi)存訪問沖突時，要考慮內(nèi)存訪問上下文中的這三個性質(zhì)：訪問是讀還是寫，訪問的時長，以及被訪問的存儲地址。特別是，沖突會發(fā)生在當(dāng)你有兩個訪問符合下列的情況：

• 至少有一個是寫訪問
• 它們訪問的是同一個存儲地址
• 它們的訪問在時間線上部分重疊

讀和寫訪問的區(qū)別很明顯：一個寫訪問會改變存儲地址，而讀操作不會。存儲地址是指向正在訪問的東西（例如一個變量，常量或者屬性）的位置的值 。內(nèi)存訪問的時長要么是瞬時的，要么是長期的。

如果一個訪問不可能在其訪問期間被其它代碼訪問，那么就是一個瞬時訪問。正常來說，兩個瞬時訪問是不可能同時發(fā)生的。大多數(shù)內(nèi)存訪問都是瞬時的。例如，下面列舉的所有讀和寫訪問都是瞬時的：

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

var myNumber = 1
myNumber = oneMore(than: myNumber)
print(myNumber)
// 打印“2”

然而，有幾種被稱為長期訪問的內(nèi)存訪問方式，會在別的代碼執(zhí)行時持續(xù)進(jìn)行。瞬時訪問和長期訪問的區(qū)別在于別的代碼有沒有可能在訪問期間同時訪問，也就是在時間線上的重疊。一個長期訪問可以被別的長期訪問或瞬時訪問重疊。

重疊的訪問主要出現(xiàn)在使用 in-out 參數(shù)的函數(shù)和方法或者結(jié)構(gòu)體的 mutating 方法里。Swift 代碼里典型的長期訪問會在后面進(jìn)行討論。

In-Out 參數(shù)的訪問沖突

一個函數(shù)會對它所有的 in-out 參數(shù)進(jìn)行長期寫訪問。in-out 參數(shù)的寫訪問會在所有非 in-out 參數(shù)處理完之后開始，直到函數(shù)執(zhí)行完畢為止。如果有多個 in-out 參數(shù)，則寫訪問開始的順序與參數(shù)的順序一致。

長期訪問的存在會造成一個結(jié)果，你不能在訪問以 in-out 形式傳入后的原變量，即使作用域原則和訪問權(quán)限允許——任何訪問原變量的行為都會造成沖突。例如：

var stepSize = 1

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

increment(&stepSize)
// 錯誤：stepSize 訪問沖突

在上面的代碼里，stepSize 是一個全局變量，并且它可以在 increment(_:) 里正常訪問。然而，對于 stepSize 的讀訪問與 number 的寫訪問重疊了。就像下面展示的那樣，number 和 stepSize 都指向了同一個存儲地址。同一塊內(nèi)存的讀和寫訪問重疊了，就此產(chǎn)生了沖突。

解決這個沖突的一種方式，是顯示拷貝一份 stepSize ：

// 顯式拷貝
var copyOfStepSize = stepSize
increment(&copyOfStepSize)

// 更新原來的值
stepSize = copyOfStepSize
// stepSize 現(xiàn)在的值是 2

當(dāng)你在調(diào)用 increment(_:) 之前做一份拷貝，顯然 copyOfStepSize 就會根據(jù)當(dāng)前的 stepSize 增加。讀訪問在寫操作之前就已經(jīng)結(jié)束了，所以不會有沖突。

長期寫訪問的存在還會造成另一種結(jié)果，往同一個函數(shù)的多個 in-out 參數(shù)里傳入同一個變量也會產(chǎn)生沖突，例如：

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(_:_:) 函數(shù)會將傳入的兩個參數(shù)平均化。將 playerOneScore 和 playerTwoScore 作為參數(shù)傳入不會產(chǎn)生錯誤 —— 有兩個訪問重疊了，但它們訪問的是不同的內(nèi)存位置。相反，將 playerOneScore 作為參數(shù)同時傳入就會產(chǎn)生沖突，因?yàn)樗鼤l(fā)起兩個寫訪問，同時訪問同一個的存儲地址。

注意

因?yàn)椴僮鞣彩呛瘮?shù)，它們也會對 in-out 參數(shù)進(jìn)行長期訪問。例如，假設(shè) balance(_:_:) 是一個名為 <^> 的操作符函數(shù)，那么 playerOneScore <^> playerOneScore 也會造成像 balance(&playerOneScore, &playerOneScore) 一樣的沖突。

方法里 self 的訪問沖突

一個結(jié)構(gòu)體的 mutating 方法會在調(diào)用期間對 self 進(jìn)行寫訪問。例如，想象一下這么一個游戲，每一個玩家都有血量，受攻擊時血量會下降，并且有能量，使用特殊技能時會減少能量。

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

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

在上面的 restoreHealth() 方法里，一個對于 self 的寫訪問會從方法開始直到方法 return。在這種情況下，restoreHealth() 里的其它代碼不可以對 Player 實(shí)例的屬性發(fā)起重疊的訪問。下面的 shareHealth(with:) 方法接受另一個 Player 的實(shí)例作為 in-out 參數(shù)，產(chǎn)生了訪問重疊的可能性。

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)  // 正常

上面的例子里，調(diào)用 shareHealth(with:) 方法去把 oscar 玩家的血量分享給 maria 玩家并不會造成沖突。在方法調(diào)用期間會對 oscar 發(fā)起寫訪問，因?yàn)樵?mutating 方法里 self 就是 oscar，同時對于 maria 也會發(fā)起寫訪問，因?yàn)?maria 作為 in-out 參數(shù)傳入。過程如下，它們會訪問內(nèi)存的不同位置。即使兩個寫訪問重疊了，它們也不會沖突。

當(dāng)然，如果你將 oscar 作為參數(shù)傳入 shareHealth(with:) 里，就會產(chǎn)生沖突：

oscar.shareHealth(with: &oscar)
// 錯誤：oscar 訪問沖突

mutating 方法在調(diào)用期間需要對 self 發(fā)起寫訪問，而同時 in-out 參數(shù)也需要寫訪問。在方法里，self 和 teammate 都指向了同一個存儲地址——就像下面展示的那樣。對于同一塊內(nèi)存同時進(jìn)行兩個寫訪問，并且它們重疊了，就此產(chǎn)生了沖突。

屬性的訪問沖突

如結(jié)構(gòu)體，元組和枚舉的類型都是由多個獨(dú)立的值組成的，例如結(jié)構(gòu)體的屬性或元組的元素。因?yàn)樗鼈兌际侵殿愋?，修改值的任何一部分都是對于整個值的修改，意味著其中一個屬性的讀或?qū)懺L問都需要訪問整一個值。例如，元組元素的寫訪問重疊會產(chǎn)生沖突：

var playerInformation = (health: 10, energy: 20)
balance(&playerInformation.health, &playerInformation.energy)
// 錯誤：playerInformation 的屬性訪問沖突

上面的例子里，傳入同一元組的元素對 balance(_:_:) 進(jìn)行調(diào)用，產(chǎn)生了沖突，因?yàn)?playerInformation 的訪問產(chǎn)生了寫訪問重疊。playerInformation.health 和 playerInformation.energy 都被作為 in-out 參數(shù)傳入，意味著 balance(_:_:) 需要在函數(shù)調(diào)用期間對它們發(fā)起寫訪問。任何情況下，對于元組元素的寫訪問都需要對整個元組發(fā)起寫訪問。這意味著對于 playerInfomation 發(fā)起的兩個寫訪問重疊了，造成沖突。

下面的代碼展示了一樣的錯誤，對于一個存儲在全局變量里的結(jié)構(gòu)體屬性的寫訪問重疊了。

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

在實(shí)踐中，大多數(shù)對于結(jié)構(gòu)體屬性的訪問都會安全的重疊。例如，將上面例子里的變量 holly 改為本地變量而非全局變量，編譯器就會可以保證這個重疊訪問是安全的：

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

上面的例子里，oscar 的 health 和 energy 都作為 in-out 參數(shù)傳入了 balance(_:_:) 里。編譯器可以保證內(nèi)存安全，因?yàn)閮蓚€存儲屬性任何情況下都不會相互影響。

限制結(jié)構(gòu)體屬性的重疊訪問對于保證內(nèi)存安全不是必要的。保證內(nèi)存安全是必要的，但因?yàn)樵L問獨(dú)占權(quán)的要求比內(nèi)存安全還要更嚴(yán)格——意味著即使有些代碼違反了訪問獨(dú)占權(quán)的原則，也是內(nèi)存安全的，所以如果編譯器可以保證這種非專屬的訪問是安全的，那 Swift 就會允許這種行為的代碼運(yùn)行。特別是當(dāng)你遵循下面的原則時，它可以保證結(jié)構(gòu)體屬性的重疊訪問是安全的：

• 你訪問的是實(shí)例的存儲屬性，而不是計算屬性或類的屬性
• 結(jié)構(gòu)體是本地變量的值，而非全局變量
• 結(jié)構(gòu)體要么沒有被閉包捕獲，要么只被非逃逸閉包捕獲了

如果編譯器無法保證訪問的安全性，它就不會允許那次訪問。