Actor — 什么是它，数据隔离和并发性

Swift 中的 Actor 是什么？

Actor — 是一种引用类型，类似于类，但具有自动的竞态保护。它是在 Swift 5.5 中作为并发系统的一部分，与 async/await 和 Task 一起引入的。Actor 保证其可变状态始终不会在没有显式同步的情况下从不同线程同时被读取或写入。

Actor 声明语法

声明 actor 使用关键字 actor，后跟包含其成员的花括号。从语法上看，actor 类似于类，但行为或彻底不同。

actor BankAccount {
    private var balance: Double
    
    init(initialBalance: Double) {
        self.balance = initialBalance
    }
    
    func deposit(amount: Double) {
        balance += amount
    }
    
    func getBalance() -> Double {
        return balance
    }
}

编译器自动隔离 actor 的所有属性和方法，使它们只能在 actor 上下文内访问。从 actor 外部尝试访问 balance 将会导致编译器报错，除非调用被标记为 async。

Actor 中的数据隔离如何工作

数据隔离 — 是 actor 的关键概念。Actor 通过 actor 执行器（actor executor）机制保证对其状态的互斥访问。每个 actor 都有自己的执行器，它顺序处理对其隔离成员的所有访问。

隔离的工作原理

当 actor 外部的代码调用其方法时，调用被放置在 actor 执行器的队列中。Actor 每次只执行一个任务，从而保证不会发生竞态。如果两个线程同时调用 deposit，第二个调用将等待第一个完成。

let account = BankAccount(initialBalance: 1000.0)
// 异步调用 — 从 actor 外部需要
await account.deposit(amount: 500.0)
let currentBalance = await account.getBalance()

每次调用 actor 方法都需要 await，因为 actor 可能正在处理其他任务。这不是 bug，而是一种有意识的设计，用于防止竞态。Swift 隐式地将 actor 属性的 getter 和 setter 变为 async，因此读取属性也需要 await。

Actor 与类的主要区别

Actor 和类都是引用类型，但它们在多线程环境中的行为截然不同。类不提供任何自动的竞态保护，而 actor 通过类型系统在编译器层面内置了这种保护。

Actor 的继承

Actor 只能从另一个 actor 继承，不能从类继承。这是有意为之的，因为类没有 actor 隔离机制，混合两种模型将导致未定义行为。

actor SavingsAccount: BankAccount {
    func applyInterest(rate: Double) {
        let interest = balance * rate
        balance += interest
    }
}

Actor 方法的异步调用

异步调用 — 是从外部代码与 actor 互动的机制。由于 actor 隔离其状态，从外部访问其成员都需要 await。这使得 Swift 能够保证调用代码不会阻塞线程，并且 actor 可以处理其他请求。

全局和本地 actor

除了声明的 actor 类型外，Swift 还支持 全局 actor — @MainActor 属性，它将类、属性或方法标记为在主线程上执行。这在使用 UIKit 和 SwiftUI 时尤其有用。

@MainActor
class ViewModel: ObservableObject {
    @Published var title: String = ""
    
    func updateTitle() {
        // 该代码保证在主线程上运行
        title = "New Title"
    }
}

使用 @MainActor 消除了手动调用 DispatchQueue.main.async 的必要，使代码更清洁、更安全。编译器检查切换到主线程是否正确发生。

Nonisolated 和 actor-isolated 上下文

Nonisolated — 是一个关键字，允许将 actor 的方法或计算属性标记为非隔离的。这些成员无法访问 actor 的隔离状态，但可以从 actor 外部无需 await 就能调用。

Nonisolated 函数

Nonisolated 方法对于不依赖于 actor 可变状态的计算很有用。例如，formatBalance 方法不直接访问 balance，只是格式化传入的值 — 这样的方法可以安全地设为 nonisolated。

actor BankAccount {
    private var balance: Double = 0
    
    nonisolated func formatBalance(amount: Double) -> String {
        return "$\(amount)"
    }
}

Nonisolated 成员同步执行，不需要 await。但它们不能直接读取 actor 的隔离属性。如果 nonisolated 方法需要来自 actor 的值，则必须将其 作为参数传递。

Reentrancy 和重新进入

Reentrancy — 是一种机制，允许在等待异步调用时重新进入 actor。如果没有 reentrancy，当 actor 的一个方法等待另一个，而另一个又回过头等待第一个时，actor 可能会永久锁死。

Reentrancy 如何工作

当 actor 内部的代码执行 await 时，actor 暂停当前任务，并可以 处理另一个排队的任务。await 完成后，任务恢复执行。这防止了死锁，但需要谨慎： actor 在 await 点之间的状态可能会改变。

actor DataProcessor {
    var cache: [Int: String] = [:]
    
    func process(id: Int) async -> String {
        if let cached = cache[id] {
            return cached
        }
        // await — 重新进入点
        let result = await fetchData(id: id)
        // 缓存可能在 await 之后发生了变化 — 请重新检查
        cache[id] = result
        return result
    }
}

开发者必须考虑 reentrancy，并在 await 点之后检查 actor 的状态。一个典型的错误是假设 actor 隔离在异步 暂停期间保持不变。实际上，在 await 和下一条语句之间，状态可能与预期的不同。