iOS 中的 @MainActor 详解

@MainActor 是 Swift 5.5 引入的一个关键属性，用于管理和确保代码在主线程上执行。在 iOS 开发中，UI 相关的操作必须在主线程上进行，@MainActor 提供了一种类型安全的方式来强制执行这一规则。

1. 基本概念

什么是 @MainActor

@MainActor 是一个全局唯一的 actor，它表示主线程的执行上下文。任何被标记为 @MainActor 的代码都会在主线程上执行。

为什么需要 @MainActor

UI 操作要求：UIKit 和 SwiftUI 都要求所有 UI 更新必须在主线程进行
数据竞争预防：防止多线程同时访问 UI 相关状态
编译器强制检查：在编译时而非运行时捕获线程问题

2. 使用方法

标记整个类

swift 复制代码

@MainActor
class MyViewController: UIViewController {
    // 所有属性和方法都会在主线程执行
    var uiData: String = ""
    
    func updateUI() {
        // 自动在主线程执行
    }
}

标记单个方法

swift 复制代码

class DataProcessor {
    var backgroundData: String = ""
    
    @MainActor
    func updateUI(with text: String) {
        // 这个方法会在主线程执行
    }
}

标记属性

swift 复制代码

class MyViewModel {
    @MainActor var uiState: UIState = .loading
    
    // 只有这个属性的访问会强制在主线程
}

标记闭包

swift 复制代码

func fetchData(completion: @MainActor @escaping (Result<Data, Error>) -> Void) {
    URLSession.shared.dataTask(with: url) { data, _, error in
        // 后台线程
        
        Task { @MainActor in
            // 回到主线程执行闭包
            if let data = data {
                completion(.success(data))
            } else {
                completion(.failure(error!))
            }
        }
    }.resume()
}

3. 与 UIKit/SwiftUI 的集成

UIKit 中的使用

swift 复制代码

@MainActor
class MyViewController: UIViewController {
    @IBOutlet weak var label: UILabel!
    
    func updateLabel(text: String) {
        label.text = text // 自动确保在主线程
    }
    
    func fetchAndUpdate() {
        Task {
            // 后台任务
            let data = await fetchData()
            
            // 自动切回主线程
            updateLabel(text: data)
        }
    }
}

SwiftUI 中的使用

SwiftUI 的 @State, @ObservedObject 等属性包装器已经隐式标记为 @MainActor：

swift 复制代码

struct ContentView: View {
    @State private var text = "" // 自动在主线程
    
    var body: some View {
        Text(text)
            .onAppear {
                Task {
                    let result = await fetchData()
                    text = result // 自动在主线程更新
                }
            }
    }
}

4. 与其他并发特性的结合

与 async/await 结合

swift 复制代码

@MainActor
func updateUI() async {
    let data = await fetchData() // 挂起，不阻塞主线程
    label.text = data // 恢复时仍在主线程
}

与 Task 结合

swift 复制代码

Task { @MainActor in
    // 这段代码会在主线程执行
    view.label.text = "Updated"
}

与非隔离代码交互

swift 复制代码

class DataLoader {
    // 非隔离方法（默认不在主线程）
    func loadData() async -> String {
        // 模拟长时间运行的任务
        await Task.sleep(1_000_000_000)
        return "Data"
    }
}

@MainActor
class MyViewModel {
    let loader = DataLoader()
    
    func loadAndUpdate() async {
        let data = await loader.loadData() // 从主线程挂起
        updateUI(with: data) // 自动回到主线程
    }
    
    func updateUI(with text: String) {
        // 已经在主线程
    }
}

5. 常见问题与解决方案

问题1：从非隔离上下文调用主线程方法

swift 复制代码

class BackgroundWorker {
    @MainActor func updateUI() { ... }
    
    func doWork() {
        updateUI() // 错误: 从非隔离上下文调用主线程方法
    }
}

解决方案：

swift 复制代码

func doWork() {
    Task { @MainActor in
        await updateUI()
    }
}

问题2：性能优化

swift 复制代码

@MainActor
class HeavyViewController {
    // 这个计算会阻塞主线程
    var expensiveProperty: SomeType {
        // 复杂计算...
    }
}

解决方案：

swift 复制代码

@MainActor
class HeavyViewController {
    nonisolated var expensiveProperty: SomeType {
        // 可以在后台线程计算
    }
}

问题3：测试中的 @MainActor

在单元测试中处理 @MainActor：

swift 复制代码

@MainActor
class MyViewModel {
    func doSomething() { ... }
}

func testViewModel() async {
    await MainActor.run {
        let viewModel = MyViewModel()
        viewModel.doSomething()
    }
}

6. 最佳实践

明确边界 ：将 UI 相关代码集中标记为 @MainActor
最小化主线程工作：只在主线程执行必要的 UI 更新
合理使用 nonisolated：对于不需要主线程的属性和方法
渐进式采用 ：在现有项目中逐步引入 @MainActor
与 DispatchQueue.main 比较 ：优先使用 @MainActor 而非 DispatchQueue.main.async

7. 与 DispatchQueue.main 的对比

特性	@MainActor	DispatchQueue.main
语法	声明式	命令式
检查时机	编译时	运行时
作用范围	精确到类型/方法	代码块
与 Swift 并发集成	完全集成	需要适配
性能	更优 (编译器优化)	常规
错误预防	强 (编译错误)	弱 (可能忘记调用)

8. 实际应用示例

网络请求 + UI 更新

swift 复制代码

@MainActor
class UserProfileViewModel: ObservableObject {
    @Published var user: User?
    @Published var isLoading = false
    @Published var error: Error?
    
    private let service: UserService
    
    init(service: UserService) {
        self.service = service
    }
    
    func loadUser() async {
        isLoading = true
        do {
            user = try await service.fetchUser()
            error = nil
        } catch {
            user = nil
            error = error
        }
        isLoading = false
    }
}

class UserService {
    nonisolated func fetchUser() async throws -> User {
        let (data, _) = try await URLSession.shared.data(from: userURL)
        return try JSONDecoder().decode(User.self, from: data)
    }
}

结合 Combine

swift 复制代码

@MainActor
class SearchViewModel: ObservableObject {
    @Published var query = ""
    @Published var results: [Result] = []
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        $query
            .debounce(for: .milliseconds(300), scheduler: DispatchQueue.main)
            .sink { [weak self] query in
                Task { [weak self] in
                    await self?.search(query: query)
                }
            }
            .store(in: &cancellables)
    }
    
    private func search(query: String) async {
        guard !query.isEmpty else {
            results = []
            return
        }
        
        do {
            results = try await SearchService().search(query: query)
        } catch {
            // 处理错误
        }
    }
}

@MainActor 是 Swift 并发模型中的重要组成部分，它提供了一种更安全、更声明式的方式来管理主线程操作，是现代 iOS 开发中不可或缺的工具。

from: deepseek