NSOperationQueue提前触发完成通知：操作未完成即回调问题

听起来你遇到的是异步任务处理里的典型坑——很多人在做联网下载这类异步操作时，都会踩这个「队列误以为任务完成」的问题。核心原因很明确：你的任务没有正确告知NSOperationQueue自己什么时候才真正完成，尤其是任务里包含异步执行的环节时，系统默认的逻辑根本感知不到内部操作的结束时机。

为什么会提前触发？ #

举个最常见的错误场景：如果你把下载、处理数据的代码直接塞进BlockOperation的block里，BlockOperation会在这个block执行完（也就是你发起下载请求的瞬间）就立刻标记自己为finished，完全不管后续的下载回调、数据处理、保存操作有没有完成。这时候队列自然会误以为所有任务都搞定了，提前触发你的完成通知。

具体解决方案 #

下面给你几个落地性强的实现方式，按需选择：

1. 正确封装异步任务到NSOperation（推荐长期复用）

如果你的任务需要反复使用，最好自定义NSOperation子类，手动管理执行状态，确保只有当所有异步流程结束后，才标记任务完成：

class DataProcessOperation: Operation {
    private let targetURL: URL
    // 手动维护执行状态，必须支持KVO
    private var _isExecuting = false
    private var _isFinished = false
    
    override var isExecuting: Bool {
        get { return _isExecuting }
        set {
            willChangeValue(forKey: "isExecuting")
            _isExecuting = newValue
            didChangeValue(forKey: "isExecuting")
        }
    }
    
    override var isFinished: Bool {
        get { return _isFinished }
        set {
            willChangeValue(forKey: "isFinished")
            _isFinished = newValue
            didChangeValue(forKey: "isFinished")
        }
    }
    
    init(url: URL) {
        self.targetURL = url
        super.init()
    }
    
    override func start() {
        // 先判断是否被取消，避免无效执行
        if isCancelled {
            isFinished = true
            return
        }
        
        isExecuting = true
        
        // 启动异步下载流程
        let downloadTask = URLSession.shared.dataTask(with: targetURL) { [weak self] data, _, error in
            guard let self = self, !self.isCancelled else {
                self?.isFinished = true
                return
            }
            
            if let validData = data {
                // 执行数据处理
                let processedData = self.processRawData(validData)
                // 执行数据保存
                self.persistData(processedData)
            }
            
            // 所有流程结束，标记任务完成
            self.isExecuting = false
            self.isFinished = true
        }
        downloadTask.resume()
    }
    
    // 模拟你的数据处理逻辑
    private func processRawData(_ data: Data) -> Data {
        return data
    }
    
    // 模拟你的数据保存逻辑
    private func persistData(_ data: Data) {}
}

使用时，通过「任务依赖」实现完成通知：

let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 4 // 支持并行执行

// 创建4个任务
let task1 = DataProcessOperation(url: URL(string: "https://example.com/data1")!)
let task2 = DataProcessOperation(url: URL(string: "https://example.com/data2")!)
let task3 = DataProcessOperation(url: URL(string: "https://example.com/data3")!)
let task4 = DataProcessOperation(url: URL(string: "https://example.com/data4")!)

// 创建完成通知任务
let completionTask = BlockOperation {
    // 切换到主线程更新UI或发通知
    DispatchQueue.main.async {
        print("所有4个任务全部完成！")
        // 这里可以触发你的业务通知，比如用NotificationCenter.post
    }
}

// 让完成任务依赖所有数据任务
completionTask.addDependency(task1)
completionTask.addDependency(task2)
completionTask.addDependency(task3)
completionTask.addDependency(task4)

// 将所有任务加入队列
operationQueue.addOperations([task1, task2, task3, task4, completionTask], waitUntilFinished: false)

2. 用DispatchGroup配合NSOperation（快速实现）

如果只是临时需求，不想自定义Operation，可以用DispatchGroup跟踪每个任务的真实完成时机：

let operationQueue = OperationQueue()
let finishGroup = DispatchGroup()

let taskURLs = [
    URL(string: "https://example.com/data1")!,
    URL(string: "https://example.com/data2")!,
    URL(string: "https://example.com/data3")!,
    URL(string: "https://example.com/data4")!
]

for url in taskURLs {
    finishGroup.enter()
    operationQueue.addOperation {
        let downloadTask = URLSession.shared.dataTask(with: url) { data, _, error in
            defer {
                finishGroup.leave() // 必须在异步回调里标记任务完成
            }
            
            if let validData = data {
                let processed = self.processRawData(validData)
                self.persistData(processed)
            }
        }
        downloadTask.resume()
    }
}

// 所有任务完成后触发通知
finishGroup.notify(queue: DispatchQueue.main) {
    print("所有任务执行完毕！")
    // 这里执行你的通知逻辑
}

⚠️ 重点提醒：finishGroup.leave()必须放在异步任务的回调里，而不是Operation的block末尾，否则还是会提前触发通知。

3. 排查常见的低级错误

• 确认你没有在任务还没加入队列时，就设置了完成监听；
• 如果你用了queue.waitUntilAllOperationsAreFinished()，不要把它放在主线程，否则会阻塞UI，也可能导致逻辑混乱；
• 检查是否不小心给任务设置了isFinished = true的提前标记。

总结 #

核心原则就是让NSOperationQueue准确感知每个任务的真实生命周期——要么通过自定义Operation管理执行状态，要么用DispatchGroup跟踪异步流程。只要解决了这个核心点，就能彻底避免提前触发完成回调的问题。

内容的提问来源于stack exchange，提问作者user-44651