启用完整并发检查后，如何将主线程耗时文件导入任务移至后台

核心问题分析 #

你的ContentView标记了@MainActor，导致其.task()默认在主线程执行，而String(contentsOf:)和后续的数据库导入操作都是耗时任务，会阻塞主线程引发卡顿，同时大文件加载会占用大量内存。需要将这些耗时逻辑移到后台线程，完成后安全回到主线程更新UI。

解决方案步骤 #

1. 把文件读取与核心导入逻辑移到后台

利用Task.detached将文件读取操作放到后台线程，或者直接让DataHandler（后台Actor）处理文件IO，避免主线程加载大文件。同时，所有UI状态更新必须通过MainActor.run回到主线程执行，满足完整并发检查要求。

2. 修正ContentView的.task与文件导入逻辑

@MainActor
struct ContentView: View {
    @Environment(\.modelContext) private var modelContext

    @State private var disable: Bool = false
    @State private var value: Double = 0
    @State var progress = ProgressItem()
    @State private var importData: Bool = false
    @State private var selectedFile: URL? = nil

    var body: some View {
        VStack {
            Button {
                disable = true
                importData = true
            } label: {
                Text("Press")
            }
            .disabled(disable) // 按钮禁用状态绑定
            .task(id: selectedFile) {
                guard let selectedFile = selectedFile else { return }
                do {
                    // 将文件读取移到后台线程执行
                    let fileContent = try await Task.detached(priority: .userInitiated) {
                        try String(contentsOf: selectedFile, encoding: .utf8)
                    }.value
                    
                    await importData(data: fileContent)
                    
                    // 回到主线程更新UI状态
                    await MainActor.run {
                        importData = false
                        disable = false
                    }
                } catch {
                    await MainActor.run {
                        print("文件读取失败：\(error.localizedDescription)")
                        importData = false
                        disable = false
                    }
                }
            }
            .fileImporter(isPresented: $importData, allowedContentTypes: [UTType.plainText], allowsMultipleSelection: false) { result in
                do {
                    guard let selectedFile: URL = try result.get().first else { return }
                    await MainActor.run {
                        self.selectedFile = selectedFile
                        progress.message = ""
                        progress.progress = 0.0
                    }
                } catch {
                    await MainActor.run {
                        print(error.localizedDescription)
                        disable = false
                    }
                }
            }
            Text("\(value)")
            // 可以添加进度展示
            Text(progress.message)
            ProgressView(value: progress.progress)
        }
    }
}

3. 优化importData方法与DataHandler

让DataHandler（后台Actor）承担更多耗时逻辑，同时在循环导入时实时更新主线程的进度：

extension ContentView {
    func importData(data: String) async {
        let actor = DataHandler(modelContainer: modelContext.container)
        await actor.readMetadata(data: data)
        
        let items = await actor.getItems()
        let totalItems = Double(items.count)
        
        for (index, item) in items.enumerated() {
            await actor.importItemsFrom(data: data)
            
            // 回到主线程更新进度
            await MainActor.run {
                progress.progress = (Double(index + 1) / totalItems)
                progress.message = "已导入 \(index + 1)/\(items.count) 项"
            }
        }
        
        print("导入完成")
    }
}

@ModelActor
actor DataHandler {
    private var metadata = [String]()
    private var nItems: Int = 0
    
    func insert<T: PersistentModel>(_ data: T) {
        modelContext.insert(data)
        try? modelContext.save()
    }

    func save() {
        try? modelContext.save()
    }
    
    func getNumItems() -> Int {
        return nItems
    }
    
    func getItems() -> [String] {
        return metadata
    }
    
    func readMetadata(data: String) {
        // 元数据解析逻辑（后台执行）
        // reads metadata and saves metadata locally in metadata
        // increment nItems
    }
    
    func importItemsFrom(data: String) {
        // 逐行解析并持久化数据（后台执行）
        // reads lines from file and persists to database using insert and save
    }
}

关键注意事项 #

• 后台执行耗时任务：通过Task.detached或@ModelActor隔离的DataHandler，确保文件读取、数据解析、数据库操作都在后台线程运行，不阻塞主线程。
• 主线程更新UI：所有@State状态的修改必须通过await MainActor.run包裹，符合完整并发检查的线程安全要求。
• 错误处理：替换try!为do-catch结构，避免崩溃并提升代码稳定性。
• 内存优化：如果是超大文件，建议直接让DataHandler读取文件URL并逐行处理，而不是加载整个文件内容到内存中。

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