前言

Swift Actors 是 Swift 5.5 中的新內(nèi)容，也是 WWDC 2021 上并發(fā)重大變化的一部分。在有 actors 之前，數(shù)據(jù)競爭是一個常見的意外情況。因此，在我們深入研究具有隔離和非隔離訪問的行為體之前，最好先了解什么是數(shù)據(jù)競爭[1]，并了解當前你如何解決這些問題[2]。

Swift 中的 Actors 旨在完全解決數(shù)據(jù)競爭問題，但重要的是要明白，很可能還是會遇到數(shù)據(jù)競爭。本文將介紹 Actors 是如何工作的，以及你如何在你的項目中使用它們。

什么是 Actors?

Swift 中的 Actor 并不新鮮：它們受到 Actor Model[3] 的啟發(fā)，該模型將行為視為并發(fā)計算的通用基元。然后，SE-0306[4]提案引入了 Actor，并解釋了它們解決了哪些問題：數(shù)據(jù)競爭。

當多個線程在沒有同步的情況下訪問同一內(nèi)存，并且至少有一個訪問是寫的時候，就會發(fā)生數(shù)據(jù)競爭。數(shù)據(jù)競爭會導致不可預(yù)測的行為、內(nèi)存損壞、不穩(wěn)定的測試和奇怪的崩潰。你可能會遇到無法解決的崩潰，因為你不知道它們何時發(fā)生，如何重現(xiàn)它們，或者如何根據(jù)理論來修復(fù)它們。

Swift 中的 Actors 可以保護他們的狀態(tài)免受數(shù)據(jù)競爭的影響，并且使用它們可以讓編譯器在編寫應(yīng)用程序時為我們提供有用的反饋。此外，Swift 編譯器可以靜態(tài)地強制執(zhí)行 Actors 附帶的限制，并防止對可變數(shù)據(jù)的并發(fā)訪問。

您可以使用 actor 關(guān)鍵字定義一個 Actor，就像您使用類或結(jié)構(gòu)體一樣：

actor ChickenFeeder {
    let food = "worms"
    var numberOfEatingChickens: Int = 0
}

Actor 和其他 Swift 類型一樣，它們也可以有初始化器、方法、屬性和子標號，同時你也可以用協(xié)議和泛型來使用它們。此外，與結(jié)構(gòu)體不同的是：當你定義的屬性需要手動定義時，actor 需要自定義初始化器。最后，重要的是要認識到 actor 是引用類型。

Actor 是引用類型，但與類相比仍然有所不同

Actor 是引用類型，簡而言之，這意味著副本引用的是同一塊數(shù)據(jù)。因此，修改副本也會修改原始實例，因為它們指向同一個共享實例。你可以在我的文章Swift 中的 Struct 與 class 的區(qū)別中了解更多這方面的信息。

然而，與類相比，Actor 有一個重要的區(qū)別：他們不支持繼承。

Swift中的Actor幾乎和類一樣，但不支持繼承。

Swift 中的 Actor 幾乎和類一樣，但不支持繼承。

不支持繼承意味著不需要像便利初始化器和必要初始化器、重寫、類成員或 open? 和 final 語句等功能。

然而，最大的區(qū)別是由 Actor 的主要職責決定的，即隔離對數(shù)據(jù)的訪問。?

如何防止數(shù)據(jù)競爭

Actors 如何通過同步來防止數(shù)據(jù)競爭。

Actor 通過創(chuàng)建對其隔離數(shù)據(jù)的同步訪問來防止數(shù)據(jù)競爭。在Actors之前，我們會使用各種鎖來創(chuàng)建相同的結(jié)果。這種鎖的一個例子是并發(fā)調(diào)度隊列與處理寫訪問的屏障相結(jié)合。受我在Concurrent vs. Serial DispatchQueue: Concurrency in Swift explained[5]一文中解釋的技術(shù)的啟發(fā)。我將向你展示使用 Actor 的前后對比。

在 Actor 之前，我們會創(chuàng)建一個線程安全的小雞喂食器，如下所示：

final class ChickenFeederWithQueue {
    let food = "worms"
    
    /// 私有支持屬性和計算屬性的組合允許同步訪問。
    private var _numberOfEatingChickens: Int = 0
    var numberOfEatingChickens: Int {
        queue.sync {
            _numberOfEatingChickens
        }
    }
    
    /// 一個并發(fā)的隊列，允許同時進行多次讀取。
    private var queue = DispatchQueue(label: "chicken.feeder.queue", attributes: .concurrent)
    
    func chickenStartsEating() {
        /// 使用柵欄阻止寫入時的讀取
        queue.sync(flags: .barrier) {
            _numberOfEatingChickens += 1
        }
    }
    
    func chickenStopsEating() {
        /// 使用柵欄阻止寫入時的讀取
        queue.sync(flags: .barrier) {
            _numberOfEatingChickens -= 1
        }
    }
}

正如你所看到的，這里有相當多的代碼需要維護。在訪問非線程安全的數(shù)據(jù)時，我們必須仔細考慮自己使用隊列的問題。需要一個柵欄標志來停止讀取并允許寫入。再一次，我們需要自己來處理這個問題，因為編譯器并不強制執(zhí)行它。最后，我們在這里使用了一個 DispatchQueue，但是經(jīng)常有圍繞著哪個鎖是最好的爭論。

為了看清這一點，我們可以使用我們先前定義的 Actor 小雞喂食器來實現(xiàn)上述例子：

actor ChickenFeeder {
    let food = "worms"
    var numberOfEatingChickens: Int = 0
    
    func chickenStartsEating() {
        numberOfEatingChickens += 1
    }
    
    func chickenStopsEating() {
        numberOfEatingChickens -= 1
    }
}

你會注意到的第一件事是，這個實例更簡單，更容易閱讀。所有與同步訪問有關(guān)的邏輯都被隱藏在Swift標準庫中的實現(xiàn)細節(jié)里。然而，最有趣的部分發(fā)生在我們試圖使用或讀取任何可變屬性和方法的時候:

Methods in Actors are isolated for synchronized access.

Actors 中的方法是隔離的，以便同步訪問。

在訪問可變屬性 numberOfEatingChickens 時，也會發(fā)生同樣的情況：

Mutable properties can only be accessed from within the Actor.

可變的屬性只能從 Actor 內(nèi)部訪問。

然而，我們被允許編寫以下代碼：

let feeder = ChickenFeeder()
print(feeder.food)

我們的喂食器上的 food 屬性是不可變的，因此是線程安全的。沒有數(shù)據(jù)競爭的風險，因為在讀取過程中，它的值不能從另一個線程中改變。

然而，我們的其他方法和屬性會改變一個引用類型的可變狀態(tài)。為了防止數(shù)據(jù)競爭，需要同步訪問，允許按順序訪問。

使用 async/await 訪問數(shù)據(jù)

使用 async/await 從 Actors 訪問數(shù)據(jù)

在 Swift 中，我們可以通過使用 await 關(guān)鍵字來創(chuàng)建異步訪問：

let feeder = ChickenFeeder()
await feeder.chickenStartsEating()
print(await feeder.numberOfEatingChickens) // Prints: 1

防止不必要的暫停

在上面的例子中，我們正在訪問我們 Actor 的兩個不同部分。首先，我們更新吃食的雞的數(shù)量，然后我們執(zhí)行另一個異步任務(wù)，打印出吃食的雞的數(shù)量。每個 await 都會導致你的代碼暫停，以等待訪問。在這種情況下，有兩個暫停是有意義的，因為兩部分其實沒有什么共同點。然而，你需要考慮到可能有另一個線程在等待調(diào)用 chickenStartsEating，這可能會導致在我們打印出結(jié)果的時候有兩只吃食的雞。

為了更好地理解這個概念，讓我們來看看這樣的情況：你想把操作合并到一個方法中，以防止額外的暫停。例如，設(shè)想在我們的 actor 中有一個通知方法，通知觀察者有一只新的雞開始吃東西：

extension ChickenFeeder {
    func notifyObservers() {
        NotificationCenter.default.post(name: NSNotification.Name("chicken.started.eating"), object: numberOfEatingChickens)
    }
}

我們可以通過使用 await 兩次來使用此代碼：

let feeder = ChickenFeeder()
await feeder.chickenStartsEating()
await feeder.notifyObservers()

然而，這可能會導致兩個暫停點，每個 await 都有一個。相反，我們可以通過從 chickenStartsEating 中調(diào)用 notifyObservers 方法來優(yōu)化這段代碼：

func chickenStartsEating() {
    numberOfEatingChickens += 1
    notifyObservers()
}

由于我們已經(jīng)在 Actor 內(nèi)有了同步的訪問，我們不需要另一個等待。這些都是需要考慮的重要改進，因為它們可能會對性能產(chǎn)生影響。

非隔離(nonisolated)訪問

Actor 內(nèi)的非隔離(nonisolated)訪問。

了解 Actor 內(nèi)部的隔離概念很重要。上面的例子已經(jīng)展示了如何通過要求使用 await 從外部參與者實例同步訪問。但是，如果您仔細觀察，您可能已經(jīng)注意到我們的 notifyObservers 方法不需要使用 await 來訪問我們的可變屬性 numberOfEatingChickens。

當訪問 Actor 中的隔離方法時，你基本上可以訪問任何其他需要同步訪問的屬性或方法。因此，你基本上是在重復(fù)使用你給定的訪問，以獲得最大的收益。

然而，在有些情況下，你知道不需要有隔離的訪問。actor 中的方法默認是隔離的。下面的方法只訪問我們的不可變的屬性 food，但仍然需要 await 訪問它:

let feeder = ChickenFeeder()
await feeder.printWhatChickensAreEating()

這很奇怪，因為我們知道，我們不訪問任何需要同步訪問的東西。SE-0313[6]的引入正是為了解決這個問題。我們可以用 nonisolated 關(guān)鍵字標記我們的方法，告訴 Swift編 譯器我們的方法沒有訪問任何隔離數(shù)據(jù)：

extension ChickenFeeder {
    nonisolated func printWhatChickensAreEating() {
        print("Chickens are eating \(food)")
    }
}

let feeder = ChickenFeeder()
feeder.printWhatChickensAreEating()

注意，你也可以對計算的屬性使用 nonisolated 的關(guān)鍵字，這對實現(xiàn) CustomStringConvertible 等協(xié)議很有幫助：

extension ChickenFeeder: CustomStringConvertible {   
    nonisolated var description: String {     
        "A chicken feeder feeding \(food)"   
    } 
}

然而，在不可變的屬性上定義它們是不需要的，因為編譯器會告訴你：

Marking immutable properties nonisolated is redundant.

將不可變的屬性標記為 nonisolated 是多余的。

為什么會出現(xiàn)數(shù)據(jù)競爭

為什么在使用 Actors 時仍會出現(xiàn)數(shù)據(jù)競爭？

當在你的代碼中持續(xù)使用 Actors 時，你肯定會降低遇到數(shù)據(jù)競爭的風險。創(chuàng)建同步訪問可以防止與數(shù)據(jù)競爭有關(guān)的奇怪崩潰。然而，你顯然需要持續(xù)地使用它們來防止你的應(yīng)用程序中出現(xiàn)數(shù)據(jù)競爭。

在你的代碼中仍然可能出現(xiàn)競爭條件，但可能不再導致異常。認識到這一點很重要，因為Actors 畢竟被宣揚為可以解決一切問題的工具。例如，想象一下兩個線程使用 await正確地訪問我們的 Actor 的數(shù)據(jù)：

queueOne.async {
    await feeder.chickenStartsEating()
}
queueTwo.async {
    print(await feeder.numberOfEatingChickens)
}

這里的競爭條件定義為：“哪個線程將首先開始隔離訪問？”。所以基本上有兩種結(jié)果：

• 隊列一在先，增加吃食的雞的數(shù)量。隊列二將打?。?
• 隊列二在先，打印出吃食的雞的數(shù)量，該數(shù)量仍為：0

這里的不同之處在于我們在修改數(shù)據(jù)時不再訪問數(shù)據(jù)。如果沒有同步訪問，在某些情況下這可能會導致無法預(yù)料的行為。

結(jié)論

Swift Actors 解決了用 Swift 編寫的應(yīng)用程序中常見的數(shù)據(jù)競爭問題?？勺償?shù)據(jù)是同步訪問的，這確保了它是安全的。我們還沒有介紹 MainActor 實例，它本身就是一個主題。我將確保在以后的文章中介紹這一點。希望您能夠跟隨并知道如何在您的應(yīng)用程序中使用 Actor。

參考資料

[1]數(shù)據(jù)競爭: https://www.avanderlee.com/swift/thread-sanitizer-data-races/#what-are-data-races?。

[2]解決這些問題: https://www.avanderlee.com/swift/thread-sanitizer-data-races/#using-the-thread-sanitizer-to-detect-data-races?。

[3]Actor Model: https://en.wikipedia.org/wiki/Actor_model?。

[4]SE-0306: https://github.com/apple/swift-evolution/blob/main/proposals/0306-actors.md?。

[5]Concurrent vs. Serial DispatchQueue: https://www.avanderlee.com/swift/concurrent-serial-dispatchqueue/。

[6]SE-0313: https://github.com/apple/swift-evolution/blob/main/proposals/0313-actor-isolation-control.md?。