前言

Actors 是 Swift 5.5 引入的一種并發(fā)編程模型，用于管理共享數(shù)據(jù)并提供數(shù)據(jù)訪問的安全性。Actors 使用異步消息傳遞來保護數(shù)據(jù)，防止數(shù)據(jù)競爭和其他并發(fā)問題。在這篇回答中，我將解釋 Actors 的基本原理，并提供一些示例代碼來說明其用法和如何防止數(shù)據(jù)競爭。

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

Actors 的基本原理

Actors 是并發(fā)編程中的一種實體，它封裝了一組相關的數(shù)據(jù)和操作，并且只能通過異步消息進行訪問。每個 Actor 在任意時刻只能執(zhí)行一個任務，從而避免了數(shù)據(jù)競爭。其他代碼通過向 Actor 發(fā)送異步消息來請求數(shù)據(jù)或執(zhí)行操作，Actor 在收到消息后逐個處理它們。

Actors 使用 async 和 await 關鍵字定義異步函數(shù)和等待異步結果，從而支持并發(fā)操作。每個 Actor 中的數(shù)據(jù)都是私有的，只能通過 Actor 提供的方法進行修改和訪問，以保證數(shù)據(jù)的一致性和安全性。

下面是一個簡單的示例，展示了如何定義和使用 Actor：

actor Counter {
    private var value = 0
    func increment() {
        value += 1
    }
    func getValue() async -> Int {
        return value
    }
}
// 創(chuàng)建 Counter Actor 實例
let counter = Counter()
// 在異步任務中調用 Actor 方法
Task {
    await counter.increment()
    let result = await counter.getValue()
    print("Counter value: \(result)")
}

在上面的代碼中，Counter 是一個簡單的 Actor，包含一個私有的 value 變量和兩個方法 increment 和 getValue。increment 方法用于增加 value 的值，getValue 方法用于獲取當前的 value 值。

在異步任務中，我們創(chuàng)建了一個 Counter 的實例 counter，并通過 await 關鍵字調用了 increment 和 getValue 方法。注意，在調用 Actor 的方法時，我們使用了 await 關鍵字來等待異步操作完成，并確保在訪問和修改 Actor 數(shù)據(jù)時的安全性。

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

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

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

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

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

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

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

數(shù)據(jù)競爭是多線程/并發(fā)編程中常見的問題，它發(fā)生在多個線程同時訪問共享數(shù)據(jù)，并且至少其中一個線程對該數(shù)據(jù)進行了寫操作。當多個線程同時讀寫共享數(shù)據(jù)時，數(shù)據(jù)的最終結果可能會產(chǎn)生不確定性，導致程序出現(xiàn)錯誤的行為。

數(shù)據(jù)競爭發(fā)生的原因主要有以下幾個方面：

1、競態(tài)條件（Race Condition）：當多個線程在沒有適當同步的情況下并發(fā)地訪問共享數(shù)據(jù)時，它們的執(zhí)行順序是不確定的。這可能導致數(shù)據(jù)的交錯讀寫，從而導致數(shù)據(jù)的最終結果出現(xiàn)錯誤。

2、缺乏同步：如果多個線程在沒有適當?shù)耐綑C制的情況下訪問共享數(shù)據(jù)，就會產(chǎn)生數(shù)據(jù)競爭。例如，多個線程同時對同一個變量進行寫操作，而沒有使用互斥鎖或其他同步機制來保證原子性。

3、共享資源的修改：當多個線程同時對共享資源進行寫操作時，就會產(chǎn)生數(shù)據(jù)競爭。如果沒有適當?shù)耐綑C制來保護共享資源的一致性，就會導致數(shù)據(jù)競爭。

4、可見性問題：多個線程可能具有各自的本地緩存或寄存器，這導致它們對共享數(shù)據(jù)的可見性存在延遲。當一個線程修改了共享數(shù)據(jù)，其他線程可能無法立即看到這個修改，從而導致數(shù)據(jù)競爭。

數(shù)據(jù)競爭可能導致程序出現(xiàn)各種問題，包括不確定的結果、崩潰、死鎖等。為了避免數(shù)據(jù)競爭，需要采取適當?shù)牟l(fā)控制措施，例如使用鎖、互斥量、信號量等同步機制來保護共享數(shù)據(jù)的訪問，或者使用并發(fā)安全的數(shù)據(jù)結構來代替共享數(shù)據(jù)。

在 Swift 中，引入了一些并發(fā)編程的機制，如 async/await 和 Actor，可以幫助開發(fā)者更容易地處理并發(fā)問題和避免數(shù)據(jù)競爭。但仍需要開發(fā)者在編寫并發(fā)代碼時注意使用正確的同步機制和遵循最佳實踐，以確保數(shù)據(jù)的安全和正確性。

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

Actors 通過限制同一時間只有一個任務可以訪問 Actor 中的數(shù)據(jù)來防止數(shù)據(jù)競爭。這種限制確保了數(shù)據(jù)的一致性和線程安全性，而無需顯式使用鎖或其他同步機制。

Actors 還提供了數(shù)據(jù)的原子性訪問和修改操作。在 Actor 內部，數(shù)據(jù)可以在異步環(huán)境中自由地修改，而不需要額外的同步操作。同時，Actors 會保證 Actor 的內部狀態(tài)在處理完一個消息之前不會被其他任務訪問，從而避免了并發(fā)問題。

在上面的示例中，我們可以看到在異步任務中通過 await 關鍵字調用 Counter 的方法。這樣做可以確保在不同的任務中對 Counter 的訪問是串行的，從而避免了數(shù)據(jù)競爭和其他并發(fā)問題。

Actors 是 Swift 中用于并發(fā)編程的一種模型，它通過異步消息傳遞來保護共享數(shù)據(jù)，并防止數(shù)據(jù)競爭。下面是一些闡述 Actors 的使用和防止數(shù)據(jù)競爭的關鍵要點：

1、定義 Actor：使用 actor 關鍵字來定義一個 Actor 類，將要保護的數(shù)據(jù)和相關操作封裝在其中。例如：

actor MyActor {
    private var sharedData: Int = 0
    func performTask() {
        // 對共享數(shù)據(jù)進行操作
    }
}

2、異步訪問：通過 async 和 await 關鍵字來標記異步函數(shù)和等待異步結果。只有通過異步函數(shù)或方法訪問 Actor 中的數(shù)據(jù)才是安全的。例如：

actor MyActor {
    private var sharedData: Int = 0
    func performTask() async {
        sharedData += 1
        await someAsyncOperation()
        let result = await anotherAsyncOperation()
        // 對共享數(shù)據(jù)進行操作
    }
}

3、 發(fā)送異步消息：通過在 Actor 實例上使用 await 關鍵字來發(fā)送異步消息，并調用 Actor 中的方法。這樣做可以確保對 Actor 的訪問是串行的，從而避免了數(shù)據(jù)競爭。例如：

let myActor = MyActor()
Task {
    await myActor.performTask()
}

4、數(shù)據(jù)保護：由于 Actors 限制了同一時間只能執(zhí)行一個任務，因此可以保證對共享數(shù)據(jù)的訪問是串行的，從而避免了數(shù)據(jù)競爭。Actors 還提供了內部狀態(tài)的保護，確保在處理一個消息之前不會被其他任務訪問。

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

在 Swift 中，使用 async/await 關鍵字來進行異步訪問數(shù)據(jù)是一種安全且方便的方式，特別適用于訪問 Actor 中的共享數(shù)據(jù)。下面是一些示例代碼來說明如何使用 async/await 訪問數(shù)據(jù)：

actor MyActor {
    private var sharedData: Int = 0
    func readData() async -> Int {
        return sharedData
    }
    func writeData(value: Int) async {
        sharedData = value
    }
}
// 創(chuàng)建 MyActor 實例
let myActor = MyActor()
// 異步讀取共享數(shù)據(jù)
Task {
    let data = await myActor.readData()
    print("Shared data: \(data)")
}
// 異步寫入共享數(shù)據(jù)
Task {
    await myActor.writeData(value: 10)
    print("Data written successfully")
}

在上面的示例中，readData 方法和 writeData 方法被標記為 async，表示它們是異步的。通過 await 關鍵字，我們可以在異步任務中等待數(shù)據(jù)的讀取和寫入操作完成。

使用 await 關鍵字調用 readData 方法時，任務會等待直到共享數(shù)據(jù)的讀取操作完成，并將結果返回。類似地，使用 await 關鍵字調用 writeData 方法時，任務會等待直到共享數(shù)據(jù)的寫入操作完成。

需要注意的是，在使用 async/await 訪問數(shù)據(jù)時，要確保訪問的方法或屬性是異步的。對于 Actor 中的方法，可以在其聲明前加上 async 關鍵字，表示它們是異步的。對于屬性，可以將其聲明為異步的計算屬性。

防止不必要的暫停

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

為了更好地理解這個概念，讓我們來看看這樣的情況：你想把操作合并到一個方法中，以防止額外的暫停。例如，設想在我們的 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 中調用 notifyObservers 方法來優(yōu)化這段代碼：

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

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

非隔離(nonisolated)訪問

在 Swift 中，非隔離（nonisolated）訪問是指在一個異步函數(shù)內部訪問類、結構體或枚舉的非隔離成員。異步函數(shù)默認情況下是隔離的，這意味著在異步函數(shù)內部只能訪問該類型的隔離成員。但有時候我們需要在異步函數(shù)中訪問非隔離成員，這時就可以使用非隔離訪問。

為了進行非隔離訪問，需要使用 nonisolated 關鍵字來修飾訪問權限。例如，假設有一個類 MyClass，其中有一個非隔離成員屬性 value：

class MyClass {
    nonisolated var value: Int = 0
}

現(xiàn)在，我們可以在異步函數(shù)內部訪問 MyClass 的 value 屬性：

func asyncFunction() async {
    let instance = MyClass()
    await doSomething(with: instance.value) // 非隔離訪問
}

需要注意以下幾點：

1、非隔離訪問只能在異步函數(shù)內部進行。在同步環(huán)境下或其他異步函數(shù)內部，仍然需要使用隔離訪問。

2、非隔離訪問是一種權限放寬的操作，因此需要謹慎使用。確保在異步函數(shù)中對非隔離成員的訪問是安全的，并且不會引入數(shù)據(jù)競爭或其他問題。

3、非隔離訪問只適用于可變性為非 nonmutating 的成員，即對可修改的成員進行訪問。對于可讀的非隔離成員，可以直接使用隔離訪問。

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

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

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

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

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

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

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

總結

使用 async/await 關鍵字來訪問數(shù)據(jù)是 Swift 中一種安全且方便的方式。在訪問 Actor 中的共享數(shù)據(jù)時，可以使用 async/await 關鍵字來標記異步方法，并通過 await 關鍵字等待讀取和寫入操作的完成。這樣可以確保數(shù)據(jù)的訪問是線程安全的，并且能夠充分利用 Swift 提供的并發(fā)編程能力。

到此這篇關于Swift 中的 Actors 使用以及如何防止數(shù)據(jù)競爭的文章就介紹到這了,更多相關Swift Actors 使用內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論