Swift并发编程中的全局执行器详解

Swift 5.5引入的并发模型彻底改变了我们编写异步代码的方式，其中执行器（Actor） 是防止数据竞争和确保线程安全的核心工具。全局执行器（Global Actor） 扩展了这一概念，为整个应用程序域提供安全、串行化的访问机制，而不仅仅是隔离单个实例。

1. Swift并发基础与执行器概述

在深入全局执行器之前，理解Swift并发模型的基础和执行器的基本概念至关重要。

1.1 为什么需要执行器？

在多线程环境中，数据竞争（Data Race） 是常见问题：当多个线程同时访问和修改同一块共享数据时，会导致不可预测的行为甚至程序崩溃。传统上，开发者使用锁（Lock）或串行调度队列（Serial Dispatch Queue）来管理同步，但这容易出错且代码冗长。

Swift的执行器（Actor） 是一种引用类型，通过执行器隔离（Actor Isolation） 保护其可变状态，确保一次只有一个线程能访问其内部数据。每个执行器内部都有一个串行执行器（Serial Executor），它像看门人一样，保证对执行器方法的调用按顺序执行。

1.2 执行器基本用法

下面是一个简单的执行器示例，它模拟了一个银行账户：

actor BankAccount {
    private var balance: Double = 0.0
    
    func deposit(amount: Double) {
        balance += amount
        print("Deposited \(amount). New balance: \(balance)")
    }
    
    func withdraw(amount: Double) async -> Bool {
        if amount <= balance {
            balance -= amount
            print("Withdrew \(amount). New balance: \(balance)")
            return true
        } else {
            print("Insufficient funds. Current balance: \(balance)")
            return false
        }
    }
    
    func getBalance() async -> Double {
        return balance
    }
}

// 使用示例
func useBankAccount() async {
    let account = BankAccount()
    
    // 存款不需要await，因为是在同一异步上下文中
    await account.deposit(amount: 100.0)
    
    // 取款需要await，因为它可能暂停
    let success = await account.withdraw(amount: 50.0)
    
    if success {
        print("Withdrawal successful")
    } else {
        print("Withdrawal failed")
    }
    
    // 查询余额也需要await
    let currentBalance = await account.getBalance()
    print("Current balance: \(currentBalance)")
}

在这个例子中：

BankAccount 被定义为一个执行器，保护 balance 状态
所有修改或读取 balance 的操作都必须通过 await 来执行
执行器自动处理同步问题，无需手动管理锁

2. @MainActor：系统提供的全局执行器

@MainActor 是Swift中最常用且最重要的全局执行器，专门用于确保UI更新在主线程上执行。

2.1 @MainActor的工作原理

@MainActor 是一个特殊的全局执行器，它将所有标记的代码与主线程关联。当从非主线程调用被 @MainActor 标记的代码时，Swift运行时会自动将这些调用调度到主线程执行。

2.2 @MainActor的使用方式

2.2.1 标记整个类

@MainActor
class ProfileViewModel: ObservableObject {
    @Published var name: String = ""
    @Published var age: Int = 0
    
    func loadUserProfile() async {
        // 模拟网络请求
        try? await Task.sleep(nanoseconds: 1_000_000_000)
        
        // 这些属性更新自动在主线程执行
        name = "John Doe"
        age = 30
    }
}

2.2.2 标记单个方法

class DataLoader {
    // 这个方法可以在任何线程调用
    func fetchData() async -> Data {
        // 模拟数据获取
        try? await Task.sleep(nanoseconds: 2_000_000_000)
        return Data() // 返回空数据作为示例
    }
    
    // 这个方法确保在主线程执行
    @MainActor
    func updateUI(with data: Data) {
        // 更新UI的操作
        print("UI updated with new data")
    }
}

2.2.3 使用 MainActor.run

func processData() async {
    let loader = DataLoader()
    let data = await loader.fetchData()
    
    // 使用MainActor.run确保UI更新在主线程
    await MainActor.run {
        // 这里可以安全地更新UI
        updateViews(with: data)
    }
}

@MainActor
func updateViews(with data: Data) {
    // UI更新代码
}

2.3 @MainActor与SwiftUI

在SwiftUI中，@MainActor 与 ObservableObject 结合使用特别强大：

@MainActor
class ShoppingCart: ObservableObject {
    @Published var items: [CartItem] = []
    @Published var total: Double = 0.0
    
    func addItem(_ item: CartItem) {
        items.append(item)
        calculateTotal()
    }
    
    func removeItem(at index: Int) {
        guard index >= 0 && index < items.count else { return }
        items.remove(at: index)
        calculateTotal()
    }
    
    private func calculateTotal() {
        total = items.reduce(0) { $0 + $1.price }
    }
}

// 在SwiftUI视图中使用
struct CartView: View {
    @StateObject var cart = ShoppingCart()
    
    var body: some View {
        VStack {
            List(cart.items) { item in
                Text(item.name)
            }
            Text("Total: \(cart.total, format: .currency(code: "USD"))")
                .font(.headline)
        }
    }
}

3. 自定义全局执行器

虽然 @MainActor 处理了UI相关的并发需求，但有时我们需要为特定功能域创建自定义的全局执行器。

3.1 创建自定义全局执行器

// 定义图像处理全局执行器
@globalActor
actor ImageProcessingActor {
    static let shared = ImageProcessingActor()
    
    // 私有初始化器防止创建其他实例
    private init() {}
}

// 定义网络操作全局执行器
@globalActor
actor NetworkActor {
    static let shared = NetworkActor()
    private init() {}
}

// 定义数据库操作全局执行器
@globalActor
actor DatabaseActor {
    static let shared = DatabaseActor()
    private init() {}
}

3.2 使用自定义全局执行器

// 标记整个类使用ImageProcessingActor
@ImageProcessingActor
class ImageProcessor {
    private var processedImages: [String: UIImage] = [:]
    
    func processImage(_ image: UIImage, withFilter filterName: String) -> UIImage {
        // 模拟耗时的图像处理
        print("Processing image with filter: \(filterName)")
        
        // 实际应用中这里会有复杂的图像处理逻辑
        let processedImage = applyFilter(image, filterName: filterName)
        
        // 缓存处理结果
        processedImages[filterName] = processedImage
        
        return processedImage
    }
    
    func getCachedImage(for filterName: String) -> UIImage? {
        return processedImages[filterName]
    }
    
    private func applyFilter(_ image: UIImage, filterName: String) -> UIImage {
        // 实际的滤镜应用逻辑
        return image
    }
}

// 标记单个方法使用NetworkActor
class ApiClient {
    @NetworkActor
    func fetchUserData() async -> UserData {
        // 模拟网络请求
        try? await Task.sleep(nanoseconds: 1_500_000_000)
        return UserData()
    }
    
    @NetworkActor
    func postUserData(_ data: UserData) async -> Bool {
        // 模拟数据上传
        try? await Task.sleep(nanoseconds: 1_000_000_000)
        return true
    }
}

3.3 跨执行器调用

在实际应用中，经常需要在不同执行器之间协调工作：

@MainActor
class UserProfileViewModel: ObservableObject {
    @Published var profileImage: UIImage?
    @Published var userData: UserData?
    @Published var isLoading = false
    
    private let imageProcessor = ImageProcessor()
    private let apiClient = ApiClient()
    
    func loadUserProfile() async {
        isLoading = true
        
        // 并行获取图像和用户数据
        async let imageTask = loadProfileImage()
        async let dataTask = loadUserData()
        
        // 等待所有任务完成
        let (image, data) = await (imageTask, dataTask)
        
        // 主线程更新UI
        self.profileImage = image
        self.userData = data
        self.isLoading = false
    }
    
    @ImageProcessingActor
    private func loadProfileImage() async -> UIImage? {
        // 从文件系统或网络加载图像
        let image = await loadImageFromNetwork()
        
        // 处理图像（在ImageProcessingActor上执行）
        return await imageProcessor.processImage(image, withFilter: "avatar")
    }
    
    @NetworkActor
    private func loadUserData() async -> UserData {
        // 从API获取用户数据
        return await apiClient.fetchUserData()
    }
    
    private func loadImageFromNetwork() async -> UIImage {
        // 模拟网络图像加载
        try? await Task.sleep(nanoseconds: 1_000_000_000)
        return UIImage()
    }
}

4. 全局执行器与协议遵循

将执行器与协议结合使用时会遇到特殊挑战，因为协议的默认要求是同步和非隔离的。

4.1 协议遵循的挑战

// 定义一个协议
protocol DataStorage {
    var data: [String] { get set }
    func addItem(_ item: String)
    func removeItem(at index: Int)
}

// 尝试让执行器遵循协议
actor MyDataStorage: DataStorage { // 错误：不符合协议要求
    var data: [String] = []
    
    func addItem(_ item: String) {
        data.append(item)
    }
    
    func removeItem(at index: Int) {
        guard index >= 0 && index < data.count else { return }
        data.remove(at: index)
    }
}

4.2 解决方案

4.2.1 使用全局执行器解决协议遵循问题

// 定义全局执行器用于数据存储
@globalActor
actor DataStorageActor {
    static let shared = DataStorageActor()
    private init() {}
}

// 使用全局执行器标记协议和实现
@DataStorageActor
protocol DataStorage {
    var data: [String] { get set }
    func addItem(_ item: String)
    func removeItem(at index: Int)
}

@DataStorageActor
class AppDataStorage: DataStorage {
    var data: [String] = []
    
    func addItem(_ item: String) {
        data.append(item)
    }
    
    func removeItem(at index: Int) {
        guard index >= 0 && index < data.count else { return }
        data.remove(at: index)
    }
}

4.2.2 使用非隔离方法

actor MyDataStorage {
    private var internalData: [String] = []
    
    // 非隔离计算属性
    nonisolated var data: [String] {
        get async {
            await getData()
        }
    }
    
    func addItem(_ item: String) {
        internalData.append(item)
    }
    
    func removeItem(at index: Int) {
        guard index >= 0 && index < internalData.count else { return }
        internalData.remove(at: index)
    }
    
    private func getData() async -> [String] {
        return internalData
    }
}

// 通过扩展提供协议遵循
extension MyDataStorage: DataStorage {
    nonisolated func addItem(_ item: String) {
        Task {
            await addItem(item)
        }
    }
    
    nonisolated func removeItem(at index: Int) {
        Task {
            await removeItem(at: index)
        }
    }
}

5. 高级主题与最佳实践

5.1 执行器重入（Reentrancy）

执行器方法在遇到 await 时可能会被挂起，此时执行器可以处理其他消息，这被称为重入。虽然提高了效率，但可能带来数据一致性问题。

actor BankAccount {
    private var balance: Double = 1000.0
    private var transactions: [String] = []
    
    func transfer(amount: Double, to recipient: BankAccount) async -> Bool {
        // 检查余额
        guard balance >= amount else {
            return false
        }
        
        // 记录交易开始
        transactions.append("开始转账: \(amount)")
        
        // await可能会挂起当前任务，执行器可以处理其他消息
        let success = await recipient.deposit(amount: amount)
        
        if success {
            balance -= amount
            transactions.append("转账成功: \(amount)")
            return true
        } else {
            transactions.append("转账失败: \(amount)")
            return false
        }
    }
    
    func deposit(amount: Double) -> Bool {
        balance += amount
        transactions.append("收到存款: \(amount)")
        return true
    }
}

最佳实践：在 await 后重新验证假设，确保状态在挂起期间没有改变。

5.2 执行器与传统异步代码的桥接

许多现有代码库使用完成处理程序（completion handlers），需要与Swift并发模型集成：

// 传统异步API
class LegacyNetworkService {
    func fetchData(completion: @escaping (Result<Data, Error>) -> Void) {
        // 模拟网络请求
        DispatchQueue.global().asyncAfter(deadline: .now() + 1.0) {
            completion(.success(Data()))
        }
    }
}

// 创建执行器来包装传统API
@globalActor
actor NetworkServiceActor {
    static let shared = NetworkServiceActor()
    private init() {}
}

@NetworkServiceActor
class ModernNetworkService {
    private let legacyService = LegacyNetworkService()
    
    func fetchData() async throws -> Data {
        return try await withCheckedThrowingContinuation { continuation in
            legacyService.fetchData { result in
                switch result {
                case .success(let data):
                    continuation.resume(returning: data)
                case .failure(let error):
                    continuation.resume(throwing: error)
                }
            }
        }
    }
}

5.3 性能考虑与执行器选择

不同的全局执行器适用于不同场景：

// 高性能计算执行器
@globalActor
actor ComputeIntensiveActor {
    static let shared = ComputeIntensiveActor()
    private init() {}
}

// I/O密集型操作执行器
@globalActor
actor IOIntensiveActor {
    static let shared = IOIntensiveActor()
    private init() {}
}

// 用户界面执行器（MainActor的替代方案，特定情况下使用）
@globalActor
actor UIActor {
    static let shared = UIActor()
    private init() {}
}

class PerformanceSensitiveService {
    @ComputeIntensiveActor
    func performComplexCalculation() async -> Double {
        // 执行复杂的数学计算
        var result = 0.0
        for i in 0..<1_000_000 {
            result += sqrt(Double(i))
        }
        return result
    }
    
    @IOIntensiveActor
    func readLargeFile() async -> String {
        // 读取大文件
        return await withCheckedContinuation { continuation in
            DispatchQueue.global().async {
                // 模拟文件读取
                let content = "Large file content..."
                continuation.resume(returning: content)
            }
        }
    }
}

5.4 测试与调试

测试全局执行器需要特殊考虑：

@MainActor
class FeatureViewModelTests: XCTestCase {
    func testFeatureViewModel() async {
        let viewModel = FeatureViewModel()
        
        // 启动异步操作
        await viewModel.loadData()
        
        // 验证结果
        XCTAssertFalse(viewModel.isLoading)
        XCTAssertEqual(viewModel.items.count, 10)
    }
}

// 自定义全局执行器的测试
@Testable
@ImageProcessingActor
func testImageProcessing() async {
    let processor = ImageProcessor()
    let testImage = UIImage()
    
    let processedImage = await processor.processImage(testImage, withFilter: "test")
    
    XCTAssertNotNil(processedImage)
    // 更多断言...
}

6. 实际应用案例

6.1 电子商务应用

// 全局执行器定义
@globalActor
actor ShoppingCartActor {
    static let shared = ShoppingCartActor()
    private init() {}
}

@globalActor
actor PaymentProcessingActor {
    static let shared = PaymentProcessingActor()
    private init() {}
}

@globalActor
actor InventoryManagementActor {
    static let shared = InventoryManagementActor()
    private init() {}
}

// 购物车管理
@ShoppingCartActor
class ShoppingCartManager {
    private var cartItems: [CartItem] = []
    private var discounts: [Discount] = []
    
    func addItem(_ item: CartItem) {
        cartItems.append(item)
        applyDiscounts()
    }
    
    func removeItem(_ itemId: UUID) {
        cartItems.removeAll { $0.id == itemId }
        applyDiscounts()
    }
    
    private func applyDiscounts() {
        // 应用折扣逻辑
    }
    
    func calculateTotal() async -> Double {
        let baseTotal = cartItems.reduce(0) { $0 + $1.price * Double($1.quantity) }
        let discountAmount = discounts.reduce(0) { $0 + $1.amount }
        return max(0, baseTotal - discountAmount)
    }
}

// 支付处理
@PaymentProcessingActor
class PaymentProcessor {
    func processPayment(amount: Double, method: PaymentMethod) async -> PaymentResult {
        // 与支付网关通信
        try? await Task.sleep(nanoseconds: 2_000_000_000) // 模拟网络延迟
        
        // 实际支付处理逻辑
        return PaymentResult(success: true, transactionId: UUID().uuidString)
    }
    
    func refundPayment(transactionId: String) async -> Bool {
        // 退款处理逻辑
        return true
    }
}

6.2 社交媒体应用

// 全局执行器定义
@globalActor
actor FeedActor {
    static let shared = FeedActor()
    private init() {}
}

@globalActor
actor SocialGraphActor {
    static let shared = SocialGraphActor()
    private init() {}
}

@globalActor
actor ContentModerationActor {
    static let shared = ContentModerationActor()
    private init() {}
}

// 动态源管理
@FeedActor
class FeedManager {
    private var posts: [Post] = []
    private var userFeed: [UUID: [Post]] = [:]
    
    func addPost(_ post: Post) async {
        // 内容审核
        let isApproved = await ContentModerationService.moderate(post.content)
        
        if isApproved {
            posts.append(post)
            await updateAllFeeds(with: post)
        }
    }
    
    private func updateAllFeeds(with post: Post) async {
        // 获取所有关注者
        let followers = await SocialGraphManager.getFollowers(of: post.authorId)
        
        for followerId in followers {
            userFeed[followerId, default: []].append(post)
        }
    }
    
    func getFeed(for userId: UUID) async -> [Post] {
        return userFeed[userId, default: []]
    }
}

// 社交图谱管理
@SocialGraphActor
class SocialGraphManager {
    private var followers: [UUID: Set<UUID>] = [:]
    private var following: [UUID: Set<UUID>] = [:]
    
    func follow(userId: UUID, targetUserId: UUID) {
        followers[targetUserId, default: []].insert(userId)
        following[userId, default: []].insert(targetUserId)
    }
    
    func unfollow(userId: UUID, targetUserId: UUID) {
        followers[targetUserId]?.remove(userId)
        following[userId]?.remove(targetUserId)
    }
    
    func getFollowers(of userId: UUID) -> Set<UUID> {
        return followers[userId, default: []]
    }
    
    func getFollowing(of userId: UUID) -> Set<UUID> {
        return following[userId, default: []]
    }
}

7. 总结

Swift的全局执行器是现代并发编程的强大工具，它们提供了一种结构化的方式来管理应用程序中的并发访问。通过 @MainActor 和自定义全局执行器，开发者可以：

确保线程安全：防止数据竞争和并发冲突
简化代码：减少手动同步的样板代码
提高可维护性：明确指定代码的执行上下文
优化性能：合理利用系统资源，避免不必要的线程阻塞

7.1 关键要点回顾

概念	用途	示例
@MainActor	UI更新和主线程操作	`@MainActor class ViewModel`
自定义全局执行器	特定功能域的隔离	`@globalActor struct MyActor`
执行器重入	处理await期间的并发	在await后重新验证状态
非隔离访问	允许同步访问只读数据	`nonisolated var computedProperty`

7.2 最佳实践

合理选择执行器类型：根据任务特性选择适当的执行器
避免执行器阻塞：在执行器内尽量减少同步工作
谨慎使用非隔离：只在安全的情况下使用非隔离访问
测试并发行为：充分测试执行器在不同并发场景下的行为

全局执行器是Swift并发模型的核心组成部分，正确使用它们可以大大简化并发编程的复杂性，同时提高应用程序的可靠性和性能。

总结

Swift的全局执行器提供了一种强大而灵活的方式来管理应用程序中的并发访问。通过系统提供的 @MainActor 和自定义全局执行器，开发者可以构建出既安全又高效的并发应用程序。关键在于理解不同执行器的特性和适用场景，遵循最佳实践，并充分利用Swift编译器的安全检查功能。