Swift 6并发实践：为整个ViewModel添加@MainActor是否为最佳实践？

嘿，这个问题问到点子上了——Swift 6里的并发安全和@MainActor的使用确实是很多开发者容易纠结的点，咱们一步步拆解来看：

1. 把整个PostViewModel标记为@MainActor是理想方案吗？ #

答案是通常不推荐。@MainActor会强制这个类的所有方法、属性都在主线程执行，但ViewModel里的核心逻辑（比如网络请求、JSON解码）根本不需要抢占主线程资源——主线程应该只处理UI更新和轻量逻辑，强行把耗时操作绑在主线程上，会浪费并发能力，甚至在数据量大解码慢时导致UI卡顿。

2. 为什么只包裹赋值块还是会出现数据竞争警告？ #

这是Swift 6中@Observable宏的特性导致的：@Observable会自动为属性添加线程安全检查，如果你的ViewModel没有标记@MainActor，但属性会被UI线程读取（比如View中访问viewModel.isLoading），那么你在后台线程对这些属性的读写（比如isLoading = true）就会和UI线程的读取产生上下文冲突，触发数据竞争警告。

哪怕你最后用MainActor.run更新posts，之前对isLoading、errorMessage的读写依然在后台线程，和UI线程的访问不在同一个actor上下文，所以警告依然会存在。

3. 整个ViewModel加@MainActor是不是“杀死了并发的目的”？ #

确实如此。虽然URLSession的data(from:)本身是异步的（系统会在后台处理网络请求），但如果整个fetchPosts方法被@MainActor包裹，那么方法中所有代码的执行上下文都会被切换到主线程——包括等待网络响应后的解码操作、状态更新逻辑。这会导致主线程被不必要的工作占用，违背了“用并发解放主线程”的初衷。

正确的重构方案：隔离耗时操作与UI状态更新 #

我们的目标是：把网络请求、JSON解码等耗时操作放在后台线程，只把UI相关的状态更新放在主线程，同时保证线程安全。这里提供两种常用的重构方式：

方式一：为UI属性单独标记@MainActor #

@Observable 
class PostViewModel {
    // 标记UI相关属性为@MainActor，强制所有读写都在主线程
    @MainActor private(set) var posts: [Post] = []
    @MainActor private(set) var errorMessage: String?
    @MainActor private(set) var isLoading: Bool = false

    // 方法本身非隔离，可以在后台线程执行
    nonisolated func fetchPosts() async {
        // 初始化加载状态：必须在主线程更新
        await MainActor.run {
            self.isLoading = true
            self.errorMessage = nil
        }

        guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts") else {
            await MainActor.run {
                self.errorMessage = "Invalid URL"
                self.isLoading = false
            }
            return
        }

        do {
            // 网络请求自动在后台执行，无需手动切换线程
            let (data, response) = try await URLSession.shared.data(from: url)
            guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
                await MainActor.run {
                    self.errorMessage = "Invalid server response"
                    self.isLoading = false
                }
                return
            }
            
            // JSON解码在后台线程执行，不阻塞主线程
            let decodedPosts = try JSONDecoder().decode([Post].self, from: data)
            
            // 最终状态更新切回主线程
            await MainActor.run {
                self.posts = decodedPosts
                self.isLoading = false
            }
        } catch {
            await MainActor.run {
                self.errorMessage = "Error fetching data: \(error.localizedDescription)"
                self.isLoading = false
            }
        }
    }
}

方式二：用后台Task执行耗时逻辑 #

另一种更灵活的写法是将耗时逻辑包裹在后台Task中，仅在需要更新状态时切回主线程：

@Observable 
class PostViewModel {
    private(set) var posts: [Post] = []
    private(set) var errorMessage: String?
    private(set) var isLoading: Bool = false

    func fetchPosts() async {
        // 启动后台Task执行耗时操作
        await Task(priority: .userInitiated) { [weak self] in
            guard let self = self else { return }
            
            // 更新加载状态到主线程
            await MainActor.run {
                self.isLoading = true
                self.errorMessage = nil
            }

            guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts") else {
                await MainActor.run {
                    self.errorMessage = "Invalid URL"
                    self.isLoading = false
                }
                return
            }

            do {
                let (data, response) = try await URLSession.shared.data(from: url)
                guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
                    await MainActor.run {
                        self.errorMessage = "Invalid server response"
                        self.isLoading = false
                    }
                    return
                }
                
                // 后台解码JSON
                let decodedPosts = try JSONDecoder().decode([Post].self, from: data)
                
                // 最终更新UI状态
                await MainActor.run {
                    self.posts = decodedPosts
                    self.isLoading = false
                }
            } catch {
                await MainActor.run {
                    self.errorMessage = "Error fetching data: \(error.localizedDescription)"
                    self.isLoading = false
                }
            }
        }.value
    }
}

核心原则总结 #

• 不要把整个ViewModel标记为@MainActor，除非它只有UI相关的轻量逻辑
• 耗时操作（网络、解码、复杂计算）必须放在后台线程
• 所有UI状态的读写必须在MainActor上下文，确保线程安全
• 利用@MainActor标记属性或MainActor.run方法，精准控制线程隔离范围

内容来源于stack exchange