将DispatchQueue.global().async转换为async/await处理同步耗时函数

针对你提到的耗时同步操作迁移场景，这里有几种更贴合Swift Concurrency原生设计的实现方式，无需依赖DispatchQueue：

方案1：用Task.detached执行后台操作，自动切回主Actor #

如果你的类是主Actor隔离的（比如@MainActor class YourClass { ... }），可以直接用Task.detached在后台执行同步耗时操作，await结果后自动回到主Actor上下文更新UI：

Task {
    // 在后台优先级的并发执行器中运行同步操作（等价于原DispatchQueue.global()）
    let processed = await Task.detached(priority: .background) {
        processData(input)
    }.value
    
    // 此处已回到主Actor，可直接修改隔离属性并更新UI
    self.processed = processed
    render()
}

方案2：包装耗时操作为nonisolated async函数 #

把同步的processData包装成一个非隔离的async函数，它默认会在后台全局并发执行器运行，调用时await后自动切回主Actor：

// 非隔离函数，默认在后台执行同步逻辑
nonisolated func processDataAsync(input: Input) async -> Output {
    processData(input)
}

// 在主Actor类内部调用
Task {
    let processed = await processDataAsync(input: input)
    self.processed = processed
    render()
}

方案3：直接修改processData为async函数（若允许修改原函数） #

如果可以调整processData的定义，直接改成async函数即可，同步逻辑会自动在后台并发执行器运行：

func processData(input: Input) async -> Output {
    // 原有的同步耗时逻辑
}

// 调用方式
Task {
    let processed = await processData(input: input)
    self.processed = processed
    render()
}

对比你原来的实现 #

你之前用withCheckedContinuation结合DispatchQueue的方式虽然可行，但属于“用Swift Concurrency的壳套GCD的逻辑”，上述方案完全基于Swift Concurrency原生机制，更符合现代Swift的异步编程范式，也避免了手动管理队列切换的繁琐。

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