如何在Swift中正确等待回调闭包结果——InfluxDB Swift API的异步适配解决方案

Hey there! I totally get the frustration—semaphores felt like a quick fix for bridging callback APIs to async/await, but Swift's evolving concurrency model is pushing us toward cleaner, non-blocking solutions. Let's replace that semaphore approach with the official Swift way to wrap callback-based code, which will eliminate those warnings and work seamlessly with Swift 6.

The Problem with Semaphores in Async Contexts #

Swift's concurrency runtime is designed to avoid blocking threads (which is what wait() does). Blocking can starve the system's thread pool and break the async/await contract, hence the warning that becomes an error in Swift 6. The right approach is to use continuations to convert callback-style code into proper async functions.

The Solution: Wrap the Callback with withCheckedThrowingContinuation #

Swift provides withCheckedThrowingContinuation (and its non-throwing sibling withCheckedContinuation) to bridge callback APIs to async/await. This lets you "pause" the async function until the callback fires, then resume it with the result or error.

Here's how to rewrite your getChargeList function:

func getChargeList(from: Int, until: Int) async throws -> [Charge] {
    let flux = """
        from(bucket: "\(self.bucket)")
        // 保留你原来的Flux查询逻辑
        """
    
    return try await withCheckedThrowingContinuation { continuation in
        self.client.queryAPI.query(query: flux) { response, error in
            // 先处理错误情况
            if let error = error {
                continuation.resume(throwing: error)
                return
            }
            
            // 确保我们有有效的响应
            guard let response = response else {
                let noResponseError = NSError(
                    domain: "InfluxDBChargeError",
                    code: -1,
                    userInfo: [NSLocalizedDescriptionKey: "No response received from InfluxDB"]
                )
                continuation.resume(throwing: noResponseError)
                return
            }
            
            do {
                // 在这里执行你的响应解析逻辑，把response转换成[Charge]
                var chargeSessions: [Charge] = []
                // ... 你的解析代码（比如遍历response结果、映射到Charge模型） ...
                
                // 解析完成，返回结果
                continuation.resume(returning: chargeSessions)
            } catch {
                // 如果解析出错，传递错误
                continuation.resume(throwing: error)
            }
        }
    }
}

Key Notes About This Approach #

• Always call continuation.resume() exactly once: Forgetting to call it will leave the async function hanging forever, and calling it more than once will cause a runtime crash. The checked continuation will even warn you if you mess this up during development.
• Error handling: Using withCheckedThrowingContinuation lets you propagate errors naturally through throws, which fits perfectly with Swift's async/await error model.
• Thread safety: The continuation automatically handles switching back to the correct execution context, so you don't need to manually dispatch to the main queue (unless your parsing code specifically requires it).

Why This Is Better Than Semaphores #

This approach is non-blocking, plays nicely with Swift's concurrency runtime, and is the official recommended way to adapt callback-based APIs until they get native async/await support. Once InfluxDB updates their Swift SDK to include async methods, you can just replace this wrapper with the official async call—no major refactoring needed.

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