如何为Swift的async/await异步函数设置超时机制？

当然可以给异步函数添加超时机制，下面提供两种实用的实现方式，适配不同Swift版本：

方法一：使用Task.withTimeout（Swift 5.7+） #

Swift 5.7引入的withTimeout是最简洁的方案，它会在指定时长后自动取消任务并抛出CancellationError，我们可以捕获这个错误返回timeout结果。

改造调用逻辑 #

如果不想修改原search函数，可以在调用时包裹超时逻辑：

// 假设你的ResultEnum定义如下
enum ResultEnum {
    case success(data: Data)
    case failure(error: Error)
    case timeout
}

Task {
    do {
        // 设置5秒超时
        let searchResult = try await Task.withTimeout(5 seconds) {
            await search()
        }
        // 处理正常返回的结果
        switch searchResult {
            case .success(let data):
                // 处理成功数据
            case .failure(let error):
                // 处理API调用错误
            default: break
        }
    } catch is CancellationError {
        // 超时触发，处理超时场景
        handleResult(.timeout)
    } catch {
        // 处理其他意外错误
        handleResult(.failure(error: error))
    }
}

func handleResult(_ result: ResultEnum) {
    switch result {
        case .timeout:
            // 执行超时后的操作
        default:
            // 其他结果处理
    }
}

封装带超时的search函数 #

如果希望search函数本身支持超时，可以把逻辑封装进去：

func search(withTimeout duration: Duration = 5 seconds) async -> ResultEnum {
    do {
        return try await Task.withTimeout(duration) {
            // 原有的多API调用逻辑
            let api1Response = await fetchFromAPI1()
            let finalData = await fetchFromAPI2(with: api1Response)
            return .success(data: finalData)
        }
    } catch is CancellationError {
        return .timeout
    } catch {
        return .failure(error: error)
    }
}

// 调用时直接指定超时（或用默认值）
Task {
    let result = await search(withTimeout: 3 seconds)
    switch result {
        case .success(let data):
            // 处理成功
        case .failure(let error):
            // 处理错误
        case .timeout:
            // 处理超时
    }
}

方法二：手动实现超时（兼容Swift 5.6及以下） #

如果你的项目还在用较低版本的Swift，可以通过创建两个Task（一个执行任务、一个处理超时），用Task.select获取先完成的结果：

func search(withTimeout seconds: TimeInterval) async -> ResultEnum {
    // 执行原搜索任务的Task
    let searchTask = Task { () -> ResultEnum in
        do {
            let api1Response = await fetchFromAPI1()
            let finalData = await fetchFromAPI2(with: api1Response)
            return .success(data: finalData)
        } catch {
            return .failure(error: error)
        }
    }
    
    // 处理超时的Task
    let timeoutTask = Task { () -> ResultEnum in
        try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
        searchTask.cancel() // 超时后取消原任务
        return .timeout
    }
    
    // 获取先完成的任务结果
    let result = await Task.select(searchTask, timeoutTask).value
    
    // 取消未完成的任务，避免资源浪费
    if !searchTask.isCancelled {
        timeoutTask.cancel()
    }
    
    return result
}

// 调用方式
Task {
    let result = await search(withTimeout: 5)
    switch result {
        // 处理所有结果场景
    }
}

注意事项 #

• 超时触发后，原任务会被取消，但如果你的API调用不支持取消（比如某些网络库未实现取消逻辑），它可能会继续在后台执行，但不会影响我们返回的超时结果。
• 如果需要确保原任务彻底停止，要确保内部的异步操作都支持Swift的任务取消机制（比如在合适的位置检查Task.isCancelled）。

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