如何遍历数组，为每个元素依次执行带依赖的API调用序列

问题背景 #

有一个长度不定的待上传元素数组，每个元素需要依次执行音频转换→音频上传→发送完成通知这一组有依赖的异步API操作。单个元素执行时逻辑正常，但直接用for循环遍历数组时，循环不会等待前一个元素的操作序列完成就启动下一个，导致操作失败。当前用DispatchGroup和BlockOperation的实现存在阻塞问题，需要可靠的有序执行方案。

原代码问题分析 #

原实现的核心问题：

• BlockOperation内部调用group.wait()会直接阻塞操作队列，导致整个队列卡死，完全失去异步执行的意义。
• 内部的asyncAfter异步任务没有正确标记BlockOperation的完成状态，BlockOperation会在执行块结束时就标记为完成，而非等待异步任务结束，导致依赖关系完全失效。
• 未处理多个元素之间的序列依赖，无法保证前一个元素的完整流程结束后再启动下一个元素的操作。

解决方案 #

1. 自定义异步Operation #

系统提供的BlockOperation无法正确处理内部包含异步任务的场景，需要子类化Operation，手动管理isExecuting、isFinished状态，确保异步任务完成后才标记操作结束。

2. 构建单个元素的操作序列 #

为每个元素创建三个异步操作（转换、上传、通知），并设置内部依赖：上传操作依赖转换操作完成，通知操作依赖上传操作完成。

3. 控制元素间的执行顺序 #

将前一个元素的最后一个操作（通知操作）作为后一个元素的第一个操作（转换操作）的依赖，确保整个元素的流程完成后才启动下一个元素的处理。

完整代码实现 #

import Foundation

// 自定义异步Operation，管理内部异步任务的完成状态
class AsyncOperation: Operation {
    private let stateQueue = DispatchQueue(label: "com.example.AsyncOperation.stateQueue")
    
    private var _isExecuting: Bool = false
    override var isExecuting: Bool {
        get { stateQueue.sync { _isExecuting } }
        set {
            willChangeValue(forKey: "isExecuting")
            stateQueue.sync { _isExecuting = newValue }
            didChangeValue(forKey: "isExecuting")
        }
    }
    
    private var _isFinished: Bool = false
    override var isFinished: Bool {
        get { stateQueue.sync { _isFinished } }
        set {
            willChangeValue(forKey: "isFinished")
            stateQueue.sync { _isFinished = newValue }
            didChangeValue(forKey: "isFinished")
        }
    }
    
    override var isAsynchronous: Bool { true }
    
    override func start() {
        if isCancelled {
            isFinished = true
            return
        }
        isExecuting = true
        main()
    }
    
    override func main() {
        // 子类重写此方法执行异步任务，完成后调用finish()
    }
    
    func finish() {
        isExecuting = false
        isFinished = true
    }
}

// 音频转换操作
class AudioConversionOperation: AsyncOperation {
    private let element: Any // 替换为你的实际元素类型
    
    init(element: Any) {
        self.element = element
        super.init()
    }
    
    override func main() {
        DispatchQueue.global().asyncAfter(deadline: .now() + Double.random(in: 2.0..<5.0)) { [weak self] in
            guard let self = self, !self.isCancelled else {
                self?.finish()
                return
            }
            print("元素\(self.element)：音频转换完成")
            self.finish()
        }
    }
}

// 音频上传操作
class AudioUploadOperation: AsyncOperation {
    private let element: Any
    
    init(element: Any) {
        self.element = element
        super.init()
    }
    
    override func main() {
        DispatchQueue.global().asyncAfter(deadline: .now() + Double.random(in: 2.0..<5.0)) { [weak self] in
            guard let self = self, !self.isCancelled else {
                self?.finish()
                return
            }
            print("元素\(self.element)：音频上传完成")
            self.finish()
        }
    }
}

// 发送上传完成通知操作
class AudioNotificationOperation: AsyncOperation {
    private let element: Any
    
    init(element: Any) {
        self.element = element
        super.init()
    }
    
    override func main() {
        DispatchQueue.main.asyncAfter(deadline: .now() + Double.random(in: 2.0..<5.0)) { [weak self] in
            guard let self = self, !self.isCancelled else {
                self?.finish()
                return
            }
            print("元素\(self.element)：已发送上传完成通知，转录开始")
            self.finish()
        }
    }
}

// 批量处理元素的方法
func processElements(_ elements: [Any]) {
    let operationQueue = OperationQueue()
    operationQueue.maxConcurrentOperationCount = 1 // 可选，依赖已保证顺序，设1更直观
    
    var previousLastOperation: Operation?
    
    for element in elements {
        // 创建当前元素的三个操作
        let conversionOp = AudioConversionOperation(element: element)
        let uploadOp = AudioUploadOperation(element: element)
        let notificationOp = AudioNotificationOperation(element: element)
        
        // 设置内部操作依赖
        uploadOp.addDependency(conversionOp)
        notificationOp.addDependency(uploadOp)
        
        // 设置元素间的依赖：前一个元素流程结束后，再启动当前元素的转换
        if let prevOp = previousLastOperation {
            conversionOp.addDependency(prevOp)
        }
        
        // 批量添加操作到队列
        operationQueue.addOperations([conversionOp, uploadOp, notificationOp], waitUntilFinished: false)
        
        // 更新前一个元素的最后操作标记
        previousLastOperation = notificationOp
    }
}

// 测试：模拟3个待处理元素
let testElements = ["元素1", "元素2", "元素3"]
processElements(testElements)

// 命令行环境需保持程序运行，APP环境可删除此行
RunLoop.main.run(until: Date().addingTimeInterval(30))

关键说明 #

• 自定义AsyncOperation解决了异步任务的状态管理问题，确保操作的isFinished状态仅在异步API完成后才更新，依赖关系才能正确生效。
• 通过元素间的依赖链，保证了全局序列的有序执行：前一个元素的所有操作完成后，才会启动下一个元素的转换操作。
• 全程无需使用DispatchGroup.wait()，彻底避免了队列阻塞问题，所有操作由OperationQueue异步调度管理。

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