在后台线程更新持久化模型：效率优化与Sendable警告问题

当前实现的功能：用户触发计算持久化Item的耗时数据时，界面显示"Computing..."，后台线程执行计算，完成后展示结果。功能正常，但存在两个问题：

1. 不确定当前实现是否为最优方案；
2. 出现编译警告：

Capture of 'self' with non-sendable type 'ItemEditView' in a @Sendable closure.
Consider making struct 'ItemEditView' conform to the 'Sendable' protocol

另外还存在疑问：是否需要保存主上下文？

相关代码 #

ItemEditView #

struct ItemEditView: View {
    @Environment(\.modelContext) private var modelContext
    let item: Item
    @State private var text = "Computing..."
    
    var body: some View {
        HStack{
            Text(text)
        }
        .task{
            Task.detached{
                do {
                    let dataManager = DataManager(modelContainer: modelContext.container) //warning here!
                    try await dataManager.computeData(for: item.id)
                    text = String(item.data!)
                    // Not sure if saving the main context is also needed
                    try modelContext.save()
                } catch {
                    print(error.localizedDescription)
                }
            }
        }
    }
}

DataManager及补充实现 #

@ModelActor
actor DataManager{
    
    func computeData(for itemID: PersistentIdentifier) async throws {
        let item = modelContext.model(for: itemID) as! Item
        item.data = expensiveWork()
        try modelContext.save()
    }
}

extension DataManager {
    private func expensiveWork() -> Double {
        for i in 0..<100_000 {
            print("\(i)")
        }
        return .random(in: 0...100)
    }
}

Item模型 #

@Model
final class Item {
    var name: String
    var data: Double?
    
    init(name: String) {
        self.name = name
    }
}

ContentView #

struct ContentView: View {
    @Query private var items: [Item]
    @Environment(\.modelContext) private var modelContext

    var body: some View {
        NavigationView {
            List {
                ForEach(items) { item in
                    VStack(alignment: .leading){
                        Text("Name: \(item.name)")
                        if let data = item.data{
                            Text("Data: \(data)")
                        }
                        NavigationLink("Compute Data"){
                            ItemEditView(item: item)
                        }
                    }
                }
                .onDelete(perform: deleteItems)
            }
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    EditButton()
                }
                ToolbarItem {
                    Button(action: addItem) {
                        Label("Add Item", systemImage: "plus")
                    }
                }
            }
        }
    }

    private func addItem() {
        withAnimation {
            let newItem = Item(name: "Name\(items.count)")
            modelContext.insert(newItem)
        }
    }

    private func deleteItems(offsets: IndexSet) {
        withAnimation {
            for index in offsets {
                modelContext.delete(items[index])
            }
        }
    }
}

1. 消除Sendable警告 #

警告根源是Task.detached的闭包要求@Sendable兼容性，但ItemEditView未遵循Sendable协议。由于ItemEditView的所有属性（modelContext、Item（@Model自动适配Sendable）、State）均线程安全，直接让结构体遵循协议即可：

struct ItemEditView: View, Sendable {
    // 原有代码不变
}

另外，Task.detached属于冗余操作——.task本身已提供异步上下文，无需脱离当前actor，直接移除Task.detached可简化代码并避免捕获self的问题：

.task{
    do {
        let dataManager = DataManager(modelContainer: modelContext.container)
        try await dataManager.computeData(for: item.id)
        text = String(item.data!)
    } catch {
        print(error.localizedDescription)
    }
}

2. 优化实现方案 #

优化DataManager的耗时操作 #

expensiveWork是同步耗时操作，会阻塞DataManager的actor线程，需将其放到后台队列执行，同时标记为nonisolated避免绑定actor上下文：

@ModelActor
actor DataManager{
    
    func computeData(for itemID: PersistentIdentifier) async throws {
        let item = modelContext.model(for: itemID) as! Item
        // 后台执行耗时操作，不阻塞actor线程
        let result = await Task.detached(priority: .background) {
            self.expensiveWork()
        }.value
        item.data = result
        try modelContext.save()
    }
}

extension DataManager {
    private nonisolated func expensiveWork() -> Double {
        for i in 0..<100_000 {
            print("\(i)")
        }
        return .random(in: 0...100)
    }
}

关于主上下文保存 #

不需要在ItemEditView中调用modelContext.save()。@ModelActor的DataManager内部调用modelContext.save()已完成持久化，且@Model对象的属性更新会自动同步到主线程上下文，视图会自动刷新。

避免强制解包风险 #

代码中text = String(item.data!)存在崩溃风险，改用可选绑定处理：

if let data = item.data {
    text = String(data)
} else {
    text = "计算无结果"
}

3. 优化后的ItemEditView完整代码 #

struct ItemEditView: View, Sendable {
    @Environment(\.modelContext) private var modelContext
    let item: Item
    @State private var text = "Computing..."
    
    var body: some View {
        HStack{
            Text(text)
        }
        .task {
            do {
                let dataManager = DataManager(modelContainer: modelContext.container)
                try await dataManager.computeData(for: item.id)
                if let data = item.data {
                    text = String(data)
                } else {
                    text = "计算无结果"
                }
            } catch {
                text = "计算失败：\(error.localizedDescription)"
                print(error.localizedDescription)
            }
        }
    }
}

内容的提问来源于stack exchange，提问作者quaternionboy