使用 SwiftData 和 @Observable 时如何避免死锁/挂起？

有人能指出我做错什么了吗？

Task.detached采用@Sendable闭包，它不能捕获非Sendable事物。但是，您使用的闭包捕获[Item]、ContentView和AppState，它们都是非Sendable。如果您打开完整的并发检查，您的代码中将出现许多警告。

您应该将整体隔离ContentView为，MainActor而不是将其各个方法标记为@MainActor。

然后，使用.task(id:)修饰符而不是 来启动任务Task.detached。如果要在非主线程上运行某些操作，请将其放在异步nonisolated func或与另一个参与者隔离的函数中。

SwiftData 模型不是- 因此“一个创建并将它们添加到队列，另一个将它们从队列中取出”Sendable的想法行不通。您应该使用某种东西，例如具有所有属性的简单结构，其中包含创建 所需的一切。您应该在将其放入上下文之前创建。Task.detachedItemTask.detachedSendableletItemIteminsert

经过这些转换之后的代码如下：

@MainActor
struct ContentView: View {
    private let logger = Logger(subsystem: "TestApp", category: "General")
    @Environment(\.modelContext) private var modelContext
    @Query private var items: [Item]
    @State private var state = AppState()
    
    @State private var testsRunning = false
    
    // when you want to cancel these tasks, just set these to false
    @State private var remoteTask = false
    @State private var syncTask = false

    
    var body: some View {
        VStack {
            Button ("Begin") {
                testsRunning = true
                runTests()
            }.disabled(testsRunning)
            Text("Remote Queue: \(state.queue.count)")
            List (items) {
                Text($0.name)
            }
        }
        .task(id: remoteTask) {
            if remoteTask {
                await startRemoteWork()
            }
        }
        .task(id: syncTask) {
            if syncTask {
                await startSync()
            }
        }
    }
}

extension ContentView {
    func runTests() {
        for item in items {
            modelContext.delete(item)
        }
        state.queue.removeAll()
        
        remoteTask = true
        syncTask = true
    }
    
    func startRemoteWork() async {
        while !Task.isCancelled {
            let newItemName = await fetchItemName()
            state.queue.append(newItemName)
            logger.info("\(Date.now): \(newItemName) added to remote queue")
        }
    }
    
    nonisolated func fetchItemName() async -> String {
        await sleep(duration: .random(in: 0.2...0.5))
        return UUID().uuidString
    }
    
    func syncQueuedItems(with itemsActor: ItemsActor) async {
        let queue = state.queue
        state.queue = []
        await itemsActor.insertItems(withNames: queue)
    }
    
    func startSync() async {
        logger.info("  \(Date.now): Sync Task Started")
        let itemsActor = ItemsActor(modelContainer: modelContext.container)
        while !Task.isCancelled {
            await syncQueuedItems(with: itemsActor)
            logger.info("  \(Date.now): Sync Task sleeping for 3 seconds till next sync")
            await sleep(duration: 3)
        }
    }
}

@ModelActor
actor ItemsActor {
    private let logger = Logger(subsystem: "ItemsActor", category: "General")
    func insertItems(withNames names: [String]) async {
        for name in names {
            let delay = Double.random(in: 0.01...0.05)
            logger.info("    \(Date.now): syncing \(name)")
            modelContext.insert(Item(name: name))
            await sleep(duration: delay)
            logger.info("    \(Date.now): Done")
            if Task.isCancelled {
                break
            }
        }
    }
}

func sleep(duration: Double) async {
    do {
        try await Task.sleep(nanoseconds: UInt64(duration * 1_000_000_000))
    } catch { fatalError("Sleep failed") }
}

• 我在商店中创建了AppState一个代表项目名称的字符串数组。这是Sendable，因此可以将其发送给模型参与者进行插入
• fetchItemName是非隔离的，因此当你使用await它时它不会在主线程上运行。
• insertItems(withNames:)与 隔离ItemsActor，因此它也不会在主线程上运行。
• 中的逻辑syncQueuedItems与您的代码略有不同。我只是将队列中的所有内容取出并插入所有内容。也可以按照您的方式进行操作，但这将涉及主要参与者和之间的大量跳跃ItemsActor。