并发编程 — MainActor
This article is extracted from the chat log with AI. Please identify it with caution.

🚀 Swift 并发中的 @MainActor 全面解析 #

在 Swift 并发编程中，@MainActor 是保证线程安全、确保代码在主线程（Main Thread）上执行的重要工具。它在处理 UI 更新、线程同步 等场景时尤为关键，尤其适用于 SwiftUI 和 UIKit 环境。

🧩 1. 什么是 @MainActor？ #

  • @MainActor 是一种全局 actor，专门用于在主线程上执行代码。
  • 适用于 UI 更新、数据绑定、以及必须在主线程运行的任务。
  • 确保标记的代码不会在后台线程执行，从而避免线程安全问题。

✅ 2. @MainActor 的基本用法 #

📄 示例 1：修饰函数 #

import SwiftUI

@MainActor
func updateUI() {
    print("当前线程：\(Thread.isMainThread ? "主线程" : "后台线程")")
}

Task {
    await updateUI()  // 确保在主线程上执行
}
  • 解释：
    • @MainActor 修饰 updateUI，确保无论从哪个线程调用，最终都会在 主线程 上执行。
    • await 确保异步代码在正确的线程调度下顺序执行。

📄 示例 2：修饰类或结构体 #

@MainActor
class ViewModel: ObservableObject {
    @Published var counter = 0

    func increment() {
        counter += 1
        print("Counter: \(counter) (线程: \(Thread.isMainThread ? "主线程" : "后台线程"))")
    }
}

let viewModel = ViewModel()

Task {
    await viewModel.increment()  // 主线程安全更新
}
  • 关键点：
    • 整个 ViewModel 类都绑定在主线程上。
    • 不再担心 counter 的线程竞争或数据同步问题。

🚀 3. 在 SwiftUI 中的应用场景 #

🌟 场景 1：异步加载数据并更新 UI #

import SwiftUI

class DataLoader: ObservableObject {
    @Published var data: String = "加载中..."

    func loadData() async {
        // 模拟异步网络请求
        try? await Task.sleep(nanoseconds: 2_000_000_000)
        await updateData("数据加载完成！") // 主线程更新
    }

    @MainActor
    private func updateData(_ newData: String) {
        self.data = newData
    }
}

struct ContentView: View {
    @StateObject private var loader = DataLoader()

    var body: some View {
        VStack {
            Text(loader.data)
                .font(.title)
                .padding()

            Button("加载数据") {
                Task {
                    await loader.loadData()
                }
            }
        }
    }
}
  • 关键逻辑：
    • 异步加载数据 loadData() 在后台线程运行。
    • 更新 UI 的操作 updateData() 由 @MainActor 保证在主线程执行，避免闪退或 UI 不一致问题。

🌈 场景 2：结合 @MainActor 与 @Published #

当你使用 @Published 属性时，通常需要确保数据变更发生在主线程。否则会收到警告或崩溃。

class CounterModel: ObservableObject {
    @Published var count = 0

    func increment() {
        Task {
            await MainActor.run {
                self.count += 1
            }
        }
    }
}
  • MainActor.run 可以在临时需要主线程执行的异步代码块中使用。

🔒 4. @MainActor 的高级用法 #

⚡ (1) MainActor.run：临时切换到主线程 #

func performBackgroundTask() async {
    print("后台线程：\(Thread.isMainThread ? "主线程" : "后台线程")")

    await MainActor.run {
        print("切换到主线程：\(Thread.isMainThread ? "主线程" : "后台线程")")
    }
}
  • 用途：
    • 当大部分任务在后台线程执行，只有一小部分需要在主线程上运行时，使用 MainActor.run 是非常高效的选择。

⚡ (2) 结合 @Sendable 保证线程安全 #

在并发闭包中，@MainActor 可与 @Sendable 一起使用，确保数据传递的安全性。

let closure: @Sendable () -> Void = {
    Task { @MainActor in
        print("主线程执行任务")
    }
}

closure()
  • 这是一种现代并发编程中常见的线程安全写法，适合异步回调或多线程环境。

❌ 5. 不正确的使用方式 #

⚠️ 错误示例：未在主线程更新 UI #

class UnsafeViewModel: ObservableObject {
    @Published var message = "初始消息"

    func loadMessage() {
        Task {
            try? await Task.sleep(nanoseconds: 1_000_000_000)
            self.message = "后台线程直接更新 UI"  // ❌ 可能导致崩溃
        }
    }
}
  • 问题：
    • 异步任务完成后，直接在后台线程更新 @Published 属性，可能导致 UI 崩溃或警告。

✅ 正确示例：使用 @MainActor 或 MainActor.run #

class SafeViewModel: ObservableObject {
    @Published var message = "初始消息"

    func loadMessage() {
        Task {
            try? await Task.sleep(nanoseconds: 1_000_000_000)
            await MainActor.run {
                self.message = "主线程安全更新 UI"  // ✅ 正确
            }
        }
    }
}

🔑 6. @MainActor 的底层原理 #

  • @MainActor 是基于 Actor 模型 实现的，确保数据的访问在单一线程（主线程）上进行。
  • 当调用 @MainActor 修饰的代码时，Swift 的运行时会自动检查当前线程：
    • 如果已经在主线程，直接执行代码。
    • 如果在后台线程，自动切换到主线程再执行。

这种机制类似于 GCD 中的 DispatchQueue.main.async，但 更简洁、更安全、且与 Swift 并发模型深度集成。

📊 7. 总结 #

特性说明
线程调度确保代码在主线程执行，避免线程竞争问题
UI 更新适合用于 SwiftUI 和 UIKit 中的 UI 更新
用法简洁支持修饰函数、类、属性，或使用 MainActor.run
线程安全保证 @Published、ObservableObject 等数据更新的线程安全
异步兼容与 async/await 完美配合，简化异步任务管理

🎯 最佳实践 #

  1. UI 相关逻辑统一使用 @MainActor 修饰，避免多线程导致的 UI 崩溃。
  2. 性能敏感的代码分离：仅将需要在主线程执行的部分使用 @MainActor，其他耗时任务仍应在后台线程处理。
  3. 临时切换使用 MainActor.run：不必为简单的主线程需求给整个类加上 @MainActor，局部使用更高效。
  4. 搭配 Task 使用，避免阻塞主线程，保证界面流畅性。

案例 A #

在 iOS 17 中，SwiftUI 引入了新的数据建模工具 SwiftData，通过 @Model 宏来声明数据模型。以下是一个结合 @Model 模型、ViewModel 和并发操作的完整示例，展示如何安全地进行数据查询和保存。

1. 定义 @Model 数据模型 #

首先用 @Model 声明一个数据模型（例如 TodoItem）:

import SwiftData

@Model
class TodoItem {
    var title: String
    var isCompleted: Bool
    
    init(title: String, isCompleted: Bool = false) {
        self.title = title
        self.isCompleted = isCompleted
    }
}

2. ViewModel 设计与并发处理 #

ViewModel 需要与 SwiftData 的 ModelContext 交互，并确保线程安全。由于 SwiftData 的上下文操作通常需要主线程，这里使用 @MainActor 标记 ViewModel：

import SwiftUI
import SwiftData

@MainActor // 确保所有操作在主线程执行
class TodoViewModel: ObservableObject {
    @Published var todos: [TodoItem] = []
    private var modelContext: ModelContext
    
    // 初始化时注入 ModelContext
    init(modelContext: ModelContext) {
        self.modelContext = modelContext
        fetchTodos() // 初始数据加载
    }
    
    // 查询数据（同步）
    func fetchTodos() {
        do {
            let descriptor = FetchDescriptor<TodoItem>(sortBy: [SortDescriptor(\.title)])
            todos = try modelContext.fetch(descriptor)
        } catch {
            print("Failed to fetch todos: \(error)")
        }
    }
    
    // 保存数据（异步安全）
    func saveTodo(title: String) async {
        let newTodo = TodoItem(title: title)
        modelContext.insert(newTodo)
        do {
            try modelContext.save() // 保存到持久化存储
            fetchTodos() // 更新本地数据
        } catch {
            print("Failed to save todo: \(error)")
        }
    }
    
    // 删除数据（异步安全）
    func deleteTodo(at offsets: IndexSet) {
        for index in offsets {
            modelContext.delete(todos[index])
        }
        do {
            try modelContext.save()
            fetchTodos()
        } catch {
            print("Failed to delete todo: \(error)")
        }
    }
}

3. 在 SwiftUI 视图中使用 #

在视图中注入 ModelContainer 和 TodoViewModel：

struct TodoListView: View {
    @Environment(\.modelContext) private var modelContext
    @StateObject private var viewModel: TodoViewModel
    
    init() {
        // 注入 ModelContext
        let context = ModelContext(TodoContainer.shared.container)
        _viewModel = StateObject(wrappedValue: TodoViewModel(modelContext: context))
    }
    
    var body: some View {
        NavigationStack {
            List {
                ForEach(viewModel.todos) { todo in
                    Text(todo.title)
                }
                .onDelete(perform: viewModel.deleteTodo)
            }
            .toolbar {
                Button("Add") {
                    Task {
                        await viewModel.saveTodo(title: "New Task")
                    }
                }
            }
        }
    }
}

// 提供 SwiftData 容器（可选单例）
enum TodoContainer {
    static let container: ModelContainer = {
        do {
            return try ModelContainer(for: TodoItem.self)
        } catch {
            fatalError("Failed to create ModelContainer: \(error)")
        }
    }()
}

4. 关键点解析 #

(1) 为什么用 @MainActor？ #

• SwiftData 的 ModelContext 操作必须发生在主线程（类似 Core Data）。 • @Published 属性更新需要触发 UI 变化，必须在主线程。

(2) 如何保证线程安全？ #

• 查询数据（fetchTodos）：直接同步调用，因为已经在主线程。 • 保存数据（saveTodo）：尽管 saveTodo 标记为 async，但实际保存操作仍发生在主线程，无需切换上下文。

(3) 何时需要 actor？ #

如果 ViewModel 需要处理与 SwiftData 无关的复杂并发操作（例如聚合网络请求和数据库操作），可以结合 actor：

actor DataProcessor {
    func processAndSave(modelContext: ModelContext) async {
        // 后台处理数据
        let processedData = await heavyProcessing()
        await MainActor.run {
            // 主线程保存到 SwiftData
            modelContext.insert(processedData)
            try? modelContext.save()
        }
    }
}

5. 最佳实践总结 #

  1. ViewModel 标记为 @MainActor：确保 SwiftData 操作和 UI 更新在主线程。
  2. 直接操作 ModelContext：不需要额外封装成 actor，除非有跨线程数据聚合需求。
  3. 避免在 ViewModel 中持有 ModelContext 长期引用：通过依赖注入传递。

这样既保证了 SwiftData 的线程安全，又符合 SwiftUI 的响应式设计模式。

案例 B #

在 SwiftUI 中使用 ViewModel 时，是否需要将其定义为 actor 取决于你的具体需求，尤其是数据的并发访问和修改方式。以下是详细的解答和建议：

1. ViewModel 是否需要是 actor？ #

  • 需要 actor 的情况：

    • 数据会被多个线程并发修改：如果你的 ViewModel 的状态（如 @Published 属性）可能被多个线程同时访问或修改（例如来自网络回调、后台任务等），则需要用 actor 保护数据一致性。
    • 避免数据竞争：Swift 的 actor 通过隔离机制确保属性和方法的串行访问，是现代 Swift 并发中推荐的方式（替代传统的锁或队列）。

  • 不需要 actor 的情况：

    • 主线程唯一访问：如果 ViewModel 的所有操作都明确运行在主线程（例如仅由 UI 触发，或通过 MainActor 标注），则不需要 actor。此时可以用 @MainActor 替代。

2. 具体实现建议 #

方案 1：使用 @MainActor（推荐大多数 UI 场景） #

大多数 SwiftUI ViewModel 的属性和方法应运行在主线程（因为会更新 UI）。此时用 @MainActor 更合适：

@MainActor
class MyViewModel: ObservableObject {
    @Published var data: [String] = []
    
    func fetchData() async {
        let newData = await DataService.fetchFromNetwork() // 假设是异步网络请求
        data = newData // 自动切换到主线程（因为被 @MainActor 隔离）
    }
    
    func saveData(_ item: String) {
        data.append(item) // 直接修改（已在主线程）
    }
}

方案 2：使用 actor（需要并发保护时） #

如果 ViewModel 有后台线程修改数据的逻辑，可以定义为 actor，但需注意从 actor 中显式切换到主线程更新 UI：

actor MyDataStore {
    private var data: [String] = []
    
    func loadData() async -> [String] {
        // 模拟异步操作
        return await mockNetworkRequest()
    }
    
    func append(_ item: String) {
        data.append(item)
    }
}

@MainActor
class MyViewModel: ObservableObject {
    @Published var uiData: [String] = []
    private let dataStore = MyDataStore()
    
    func refresh() async {
        let loadedData = await dataStore.loadData()
        uiData = loadedData // 主线程更新
    }
}

3. 数据查询和保存的常见模式 #

查询数据 #

  • 异步方法：通过 async/await 从数据库或网络获取数据。
  • 线程切换：确保结果最终在主线程更新 @Published 属性。
@MainActor
class MyViewModel: ObservableObject {
    @Published var items: [Item] = []
    
    func loadItems() async {
        items = await Database.shared.fetchItems() // 假设是异步数据库查询
    }
}

保存数据 #

  • 直接修改：如果操作简单且在主线程，可直接修改 @Published 属性。
  • 委托给 Actor：复杂操作或需要线程保护时，通过 actor 处理。
// 通过 Actor 保护写入
actor ItemDatabase {
    func save(_ item: Item) async {
        // 保存到数据库或文件
    }
}

@MainActor
class MyViewModel: ObservableObject {
    private let database = ItemDatabase()
    
    func addItem(_ item: Item) async {
        await database.save(item)
        await loadItems() // 重新加载数据
    }
}

4. 关键注意事项 #

  • UI 更新必须在主线程：所有 @Published 属性的修改应发生在主线程（用 @MainActor 保证）。
  • 避免阻塞主线程：耗时的数据操作（如数据库查询）应在后台完成，再切回主线程更新状态。
  • Combine 兼容性：如果混用 Combine，确保订阅接收器在主线程（如 receive(on: DispatchQueue.main)）。

总结 #

  • 默认情况：用 @MainActor 标注 ViewModel，适合大多数 UI 驱动场景。
  • 复杂并发：结合 actor 保护后台数据操作，再通过 @MainActor 更新 UI。
  • 数据访问模式：async/await 提供更安全的并发，替代传统回调或 Combine。
本文共 3735 字，创建于 Feb 5, 2025
相关标签： Swift, Xcode, ByAI