异步顺序执行

要求：异步耗时操作：ADC先完成，再完成DE，最后完成FGHI

1、任务组(DispatchGroup)实现

    func testWorkItem() {
        let item0 = creatWorkItem(tag: "A")
        let item1 = creatWorkItem(tag: "B")
        let item2 = creatWorkItem(tag: "C")
        
        let item3 = creatWorkItem(tag: "D")
        let item4 = creatWorkItem(tag: "E")
        
        let item5 = creatWorkItem(tag: "F")
        let item6 = creatWorkItem(tag: "G")
        let item7 = creatWorkItem(tag: "H")
        let item8 = creatWorkItem(tag: "I")
        
        let queue = DispatchQueue(label: "processQueueName1", attributes: .concurrent)
        let group = DispatchGroup.init();
        
        queue.async(group: group, execute: item0)
        queue.async(group: group, execute: item1)
        queue.async(group: group, execute: item2)
        item0.notify(queue: queue) {
            print("A完成--- \(Thread.current)")
        }
        item1.notify(queue: queue) {
            print("B完成--- \(Thread.current)")
        }
        item2.notify(queue: queue) {
            print("C完成--- \(Thread.current)")
        }
        
        item3.notify(queue: queue) {
            print("D完成--- \(Thread.current)")
        }
        item4.notify(queue: queue) {
            print("E完成--- \(Thread.current)")
        }
        
        item5.notify(queue: queue) {
            print("F完成--- \(Thread.current)")
        }
        item6.notify(queue: queue) {
            print("G完成--- \(Thread.current)")
        }
        item7.notify(queue: queue) {
            print("H完成--- \(Thread.current)")
        }
        item8.notify(queue: queue) {
            print("I完成--- \(Thread.current)")
        }
        
        group.notify(queue: queue) {
            print("第一组完成--- \(Thread.current)")
            queue.async(group: group, execute: item3)
            queue.async(group: group, execute: item4)
            
            group.notify(queue: queue, execute: {
                print("第2组完成--- \(Thread.current)")
                queue.async(group: group, execute: item5)
                queue.async(group: group, execute: item6)
                queue.async(group: group, execute: item7)
                queue.async(group: group, execute: item8)
                
                group.notify(queue: queue, execute: {
                    print("第3组完成--- \(Thread.current)")
                })
            })
        }
    }
   
    func creatWorkItem(tag: String) -> DispatchWorkItem{
        let item = DispatchWorkItem.init {
            print("\(tag)==========start")
            for idx in 1..<5
            {
                print("\(tag):\(idx) --- \(Thread.current)")
                sleep(1)
            }
            print("\(tag)==========end")
        }
        return item
    }

2、栅栏函数

   func testWorkItem1() {
        let item0 = creatWorkItem(tag: "A")
        let item1 = creatWorkItem(tag: "B")
        let item2 = creatWorkItem(tag: "C")
        
        let item3 = creatWorkItem(tag: "D")
        let item4 = creatWorkItem(tag: "E")
        
        let item5 = creatWorkItem(tag: "F")
        let item6 = creatWorkItem(tag: "G")
        let item7 = creatWorkItem(tag: "H")
        let item8 = creatWorkItem(tag: "I")
        
        let queue = DispatchQueue(label: "processQueueName1", attributes: .concurrent)
        let group = DispatchGroup.init();
        
        queue.async(group: group, execute: item0)
        queue.async(group: group, execute: item1)
        queue.async(group: group, execute: item2)
        
        queue.async(flags: .barrier) {
            print("======第一组完成======")
        }
        
        queue.async(group: group, execute: item3)
        queue.async(group: group, execute: item4)
        queue.async(flags: .barrier) {
            print("======第二组完成======")
        }

        queue.async(group: group, execute: item5)
        queue.async(group: group, execute: item6)
        queue.async(group: group, execute: item7)
        queue.async(group: group, execute: item8)
        
    }