多线程研究一：NSOperation实现GCD group依赖

下一篇：多线程研究二：NSBlockOperation通过判断isCancled停止block执行

本文demo GitHub：MultithreadSample
参考：

• iOS 多线程：『GCD』详尽总结
• iOS 多线程：『NSOperation、NSOperationQueue』详尽总结
• iOS 并发编程之 Operation Queues

前言

在开发中最常用的就是使用gcd的dispatch_async方法实现多线程，但是在一些特定场景下，需要一个线程在其他多个线程执行完成后在执行，典型场景就是同时上传多张图片到图床服务器(如七牛),全部上传完后再请求自己的接口服务器，这个场景使用dispath_group+dispatch_queue的方式很好实现，但是由于NSOperation的能，希望取消、能监听状态等优势，希望可以用NSOperation来实现，经过研究，发现使用NSOperation的依赖接口，实现一对多的依赖实现同样的功能

重点：需要先添加NSOperation的依赖，然后再添加到NSOperationQueue

GCD实现组依赖

    class func testGCDGroupDependency() -> Void
    {
        let group = DispatchGroup()
        let queue = DispatchQueue(label: "labelname", qos: .default, attributes: .concurrent, autoreleaseFrequency: .inherit)
        for i in 0..<10 {
            let temps:Int = Int(arc4random_uniform(3))+3
            queue.async(group: group, execute: DispatchWorkItem(block: {
                Thread.sleep(forTimeInterval: TimeInterval(temps))
                print("###swift-gcd i \(i)-\(temps)-\(Thread.current)")
            }))
            
        }
        queue.async(group: group, execute: DispatchWorkItem(block: {
            print("###swift-gcd-------\(Thread.current)")
        }))
        
        group.notify(queue: DispatchQueue.main, work: DispatchWorkItem(block: {
            print("###swift-gcd+++++-\(Thread.current)")
        }))
        
    }

---

NSOperation实现组依赖

方式一、

使用NSOperation可以添加多个依赖的特点，把需要放到最后一个执行的Operation对其他的Operation都添加一个依赖，这样就能达到其他Operation执行完成后再执行指定Operation了

    class func testOperationGroupDependency1() -> Void
    {
        var ops: [Operation] = []
        // 需要循环遍历添加执行任务的场景
        for i in 0..<10 {
            let temps:Int = Int(arc4random_uniform(3))+1
            ops.append(BlockOperation(block: {
                sleep(UInt32(temps))
                print("###swift-operation1 i \(i)-\(temps)-\(Thread.current)")
            }))
        }
        // 不是遍历添加的需要单独添加的任务
        let op1 = BlockOperation {
            print("###swift-operation1 -------\(Thread.current)")
        }
        ops.append(op1)
        let op2 = BlockOperation {
            DispatchQueue.main.async {
                print("###swift-operation1 +++++-\(Thread.current)")
            }
            
        }
        // 最后执行的任务对其他所有任务都添加依赖
        for op in ops {
            op2.addDependency(op)
        }
        ops.append(op2)
        let queue = OperationQueue()
        // 添加到任务队列中执行
       queue.addOperations(ops, waitUntilFinished: false)
    }

方式二、

使用NSBlockOperation可以添加多个执行Block的特点，把每个任务都做成一个block添加，然后再使用NSOperation可以添加一个completeBlock，并且completeBlock会在本Operation的所有Block都执行完后才会执行的特点进行group依赖

class func testOperationGroupDependency2() -> Void
    {
        let operation: BlockOperation = BlockOperation()
        // 需要循环遍历添加执行任务的场景
        for i in 0..<10 {
            let temps:Int = Int(arc4random_uniform(3))+1
            operation.addExecutionBlock {
                sleep(UInt32(temps))
                print("###swift-operation2 i:\(i)-wait:\(temps)-thread:\(Thread.current)")
            }
        }
        // 不是遍历添加的需要单独添加的任务
        operation.addExecutionBlock {
            print("###swift-operation2 -------\(Thread.current)")
        }
        // 最后执行的任务
        operation.completionBlock = {
            DispatchQueue.main.async {
                print("###swift-operation2 +++++-\(Thread.current)")
            }
        }
        // 单个Operation可以直接使用start方法执行，也可以添加到OperationQueue中执行
       // operation.start()
        let queue = OperationQueue()
        queue.addOperation(operation)
    }

方式三、

结合方式一、方式二，将一部分任务通过Block添加到一个NSBlockOperation里，然后部分任务单独创建一个NSOperation，最后要执行的Operation对所有Operation进行依赖

 class func testOperationGroupDependency3() -> Void
    {
        let op0: BlockOperation = BlockOperation()
        // 需要循环遍历添加执行任务的场景
        for i in 0..<10 {
            let temps:Int = Int(arc4random_uniform(3))+1
            op0.addExecutionBlock {
                sleep(UInt32(temps))
                print("###swift-operation3 i:\(i)-wait:\(temps)-thread:\(Thread.current)")
            }
        }
        // 不是遍历添加的需要单独添加的任务
        // swift没有NSInvocationOperation，Objective-C里有，
        //一些场景下比如原有代码里已经存在一个方法可以实现需求，只需要用NSInvocationOperation的target、selector就能做到了
        let op1 = BlockOperation{
            print("###swift-operation3 -------\(Thread.current)")
        }
        // 需要之前的任务都完成后再执行的任务
        let op2 = BlockOperation {
            DispatchQueue.main.async {
                print("###swift-operation3 +++++-\(Thread.current)")
            }
            
        }
        // 最后执行的任务对其他所有任务都添加依赖
        op2.addDependency(op0)
        op2.addDependency(op1)
        // 添加到任务队列中执行
        let queue = OperationQueue()
        queue.addOperations([op0,op1,op2], waitUntilFinished: false)
    }