在学习的过程中，发现这样一句话“在 SwiftUI 中，@State 属性是视图的一部分，它们被视为 actor 隔离的’“，这句话的意思是，@State 属性在 SwiftUI 中具有隔离性，它们的状态和管理与视图层次结构绑定，并且 Swift 会确保这些属性在多线程环境中是安全的。
我们将通过@State的Actor隔离来引出本次的科普知识“Actor隔离”。
理解@State的Actor隔离
1、@State 是 View 的私有状态：
在 SwiftUI 中，@State 属性是专门为视图设计的，它允许视图拥有自己的私有状态。在视图生命周期内，这些属性可以用来存储和更新数据。
视图会观察 @State 的变化，并在状态更新时自动重新渲染视图。
2、线程安全：
Swift 的并发模型会自动保证 @State 的访问是安全的。这意味着即使多个任务（或线程）尝试访问或更新 @State，系统也会确保操作的正确性，避免数据竞争。
从技术上讲，可以认为 SwiftUI 视图的 @State 属性是与视图隔离的，类似于 actor 的概念：actor 负责其内部数据的隔离与保护，而 @State 也是被隔离和保护的。
3、避免数据竞争：
数据竞争（data race）指的是多个线程同时访问并修改数据，导致数据不一致。actor 和 SwiftUI 中的 @State 都通过线程安全的机制，确保数据竞争不会发生。
比如，在 SwiftUI 中如果一个 @State 属性在主线程更新，那么你不需要担心其他地方访问 @State 会出现竞争情况，因为 SwiftUI 的机制会处理这些更新，确保它们按顺序执行。
举例说明
struct CounterView: View {
@State private var count = 0
var body: some View {
VStack {
Text("Count: \(count)")
Button("Increment") {
count += 1
}
}
}
}在这个例子中，count 是一个 @State 属性。虽然可能有多个操作（例如用户点击按钮，导致 count 变化），SwiftUI 会确保 count 的状态更新是线程安全的。
当按钮点击时，SwiftUI 会自动管理 @State，并决定什么时候更新视图，不会出现并发问题。这种机制与 actor 的隔离性类似，@State 是由 SwiftUI 保护和管理的，确保不会有意外的并发访问。
@State 属性被称为 “actor 隔离的”，意味着 SwiftUI 自动处理对这些属性的访问，使它们在并发环境下也是安全的。虽然不是直接使用 actor 机制，但 SwiftUI 的设计理念和 actor 类似，都保证了数据的隔离性和安全性。
Actor 隔离
Actor 隔离是 Swift 中的一种并发控制机制，用来确保数据安全地在多线程环境下访问和修改。它是通过引入 actor 这种类型来实现的。actor 提供了一种方式，让你能够在多线程并发编程中避免数据竞争（data race），从而确保数据访问的安全性和一致性。
Actor 隔离的概念
在 Swift 中，actor 就像类一样，是一种引用类型，但它有一个重要的特性：actor 隔离。这个特性确保 actor 内部的数据只能被同一个 actor 本身直接访问，其他代码要想访问它，必须通过异步调用。这种设计可以有效地避免并发环境下的竞争条件和数据不一致的问题。
如何理解 Actor 隔离
封装和隔离： actor 的内部状态（比如属性）默认是“隔离的”，外部代码无法直接访问或修改。所有对 actor 内部状态的访问都必须通过 actor 提供的异步方法。
异步访问： 当其他代码（在不同的线程上）需要访问 actor 的数据时，必须使用 await，以确保调用是线程安全的。这是因为 actor 会在内部处理这些访问请求，使其逐个执行，从而避免数据竞争。
线程安全： actor 自动处理线程同步，你不需要手动使用锁或者其他同步机制。因为 actor 的隔离机制保证了对内部状态的安全访问。
使用示例
假设我们有一个计数器类，如果没有使用 actor，在多线程情况下可能会导致数据竞争：
class Counter {
var value = 0
func increment() {
value += 1
}
}在多线程访问时，value 的操作就可能发生数据竞争，导致计数不准确。
使用 actor 来解决：
actor Counter {
var value = 0
func increment() {
value += 1
}
}如何定义和使用 Actor
定义 Actor
你可以像定义类一样定义一个 actor：
actor BankAccount {
var balance: Double = 0.0
func deposit(amount: Double) {
balance += amount
}
func withdraw(amount: Double) {
if amount <= balance {
balance -= amount
}
}
}在这个例子中，BankAccount 是一个 actor，它有一个属性 balance 和两个方法 deposit 和 withdraw。由于 actor 的线程安全特性，我们可以确保在并发环境下 balance 始终保持一致。
创建 Actor 实例
使用 actor 实例与类实例类似：
let account = BankAccount()调用 Actor 的方法
由于 actor 的内部状态是隔离的，因此在访问 actor 的方法或属性时，通常需要使用 await 进行异步调用：
Task {
await account.deposit(amount: 100)
await account.withdraw(amount: 50)
print(await account.balance) // 50.0
}上面的代码通过 Task 来创建一个异步任务，并使用 await 调用 deposit 和 withdraw 方法。
在 Actor 内部直接访问
在 actor 的内部，方法和属性可以直接访问而不需要 await，因为它们属于同一个线程上下文，不涉及并发。
actor 内部的数据只能被同一个 actor 本身直接访问。
只有 actor 自己能安全地在其内部操作这些属性或方法。外部代码（在 actor 外部的线程或任务）不能直接访问或修改 actor 内部的数据，而必须通过异步调用来访问，这样可以确保 actor 的状态在多线程环境下始终保持一致。
actor BankAccount {
private var balance: Double = 0.0
func deposit(amount: Double) {
balance += amount
}
func getBalance() -> Double {
return balance
}
}
let account = BankAccount()
Task {
await account.deposit(amount: 100.0) // 外部访问，需要 await
let balance = await account.getBalance() // 外部访问，需要 await
print(balance)
}在上面的 BankAccount 例子中，balance 是一个 private 属性，只能通过 actor 自己的 deposit 和 getBalance 方法访问。外部任务如果想要查看或修改 balance，必须通过异步调用 deposit 或 getBalance，并使用 await 关键字。
这种设计保证了 actor 内部状态不会受到外部直接修改的影响，从而避免了数据竞争和状态不一致的问题。
访问隔离的特性
actor 内部的属性和方法是隔离的，不允许从外部直接访问：
let counter = Counter()
// 这会报错，因为不能直接访问隔离的属性
print(counter.count) // ❌
// 必须通过异步调用
Task {
print(await counter.count) // ✅
}注意：属性和方法都需要使用await，而不单单是方法。
Actor 的 nonisolated 修饰符
如果你希望在 actor 中定义一个方法，但希望它可以从外部同步调用，你可以使用 nonisolated 修饰符：
actor Logger {
func log(message: String) {
print("Log: \(message)")
}
nonisolated func getCurrentTime() -> String {
return Date().description
}
}
let logger = Logger()
// 可以同步调用 nonisolated 方法
print(logger.getCurrentTime()) // ✅ 不需要 await在上面的例子中，getCurrentTime 被标记为 nonisolated，因此可以直接同步调用而无需 await。
注意：actor 的属性或方法都可以标记为 nonisolated，这表示它们不受 actor 的隔离约束。标记为 nonisolated 的属性或方法可以像普通的类属性或方法一样访问，不需要 await。
Actor 与类的不同点
线程安全： actor 会自动处理并发访问，保证线程安全，而类在并发情况下会有数据竞争的问题。
异步访问： 由于 actor 的隔离特性，外部访问 actor 的属性和方法时需要使用 await 进行异步调用。
锁机制： actor 内部使用了锁机制来保证操作的顺序性，但不需要手动加锁。
使用 Actor 的好处
数据安全： actor 会自动确保内部状态在并发访问时的安全性。
避免手动加锁： 不需要使用 DispatchQueue 或 NSLock 之类的手动同步工具。
简化并发编程： Actor 隔离让代码更易于编写和理解，因为你不需要担心并发访问的数据一致性问题。
实际应用场景
actor 非常适合用于需要并发控制的场景，比如网络请求、数据缓存、用户输入处理等。
actor DataCache {
private var cache: [String: Data] = [:]
func getData(for url: String) async -> Data? {
return cache[url]
}
func setData(_ data: Data, for url: String) {
cache[url] = data
}
}这样在多线程环境中使用 DataCache 时，所有对 cache 的访问都是安全的，不会产生数据竞争。
总结
actor 提供了一种简单但强大的机制，用来处理并发访问和数据竞争问题。在 Swift 并发编程中，通过 actor 可以更轻松地实现线程安全，从而避免手动同步操作的复杂性。如果你的应用程序中存在需要保证数据一致性的多线程场景，actor 是一个非常有用的工具。
