Swift队列组、信号量

应用场景：一个页面有6个请求，请求完毕后统一刷新UI

基础使用：

func initData() -> Void {
        let group = DispatchGroup()
        let queue = DispatchQueue.global()
        
        queue.async(group: group, execute: {
            uLog("11111111")
        })

        queue.async(group: group, execute: {
                uLog("222")
        })

        queue.async(group: group, execute: {
                uLog("3333")
        })

        queue.async(group: group, execute: {
                uLog("4444")
        })
        queue.async(group: group, execute: {
            uLog("555")
        })
        
        ///只要任务全部完成了,就会在最后调用
        group.notify(queue: queue) {
            uLog("完结咯，刷新UI")
        }
    }

结果：无序输出，最后输出完结

网络请求进阶版：

func initData() -> Void {
        let group = DispatchGroup()
        let queue = DispatchQueue.global()
        
        queue.async(group: group, execute: {
            ///通知 group,下个任务要放入 group 中执行
            group.enter()

            ///模拟网络请求
            queue.asyncAfter(deadline: .now() + 4) {
                uLog("11111111")
                ///通知 group,任务成功完成,要移除,与 enter成对出现
                group.leave()
            }
        })
        queue.async(group: group, execute: {
            group.enter()

             ///模拟网络请求
            queue.asyncAfter(deadline: .now() + 1) {
                uLog("222")
                group.leave()
            }
        })

        queue.async(group: group, execute: {
            group.enter()

             ///模拟网络请求
            queue.asyncAfter(deadline: .now() + 6) {
                uLog("3333")
                group.leave()
            }
        })
        queue.async(group: group, execute: {
            group.enter()
            
             ///模拟网络请求
            queue.asyncAfter(deadline: .now() + 10) {
                uLog("4444")
                group.leave()
            }
        })
        queue.async(group: group, execute: {
            group.enter()
            uLog("555")
            group.leave()
        })
        
        ///只要任务全部完成了,就会在最后调用
        group.notify(queue: queue) {
            uLog("完结咯，刷新UI")
        }
    }

打印结果：
5，2，1，3，4，完结

也可用信号量，感觉没有这样简单

信号量

相当于一把锁，信号量为0则阻塞线程，大于0则不会阻塞。则我们通过改变信号量的值，来控制是否阻塞线程，从而达到线程同步

// 创建一个信号，value：信号量
    let semaphore = DispatchSemaphore.init(value: <#T##Int#>)
    // 某个信号进行等待或等待降低信号量,只有当信号量大于0时才会停止等待，继续向下执行
    semaphore.wait()
    // 使某个信号的信号量+1
    semaphore.signal()

func semaphore_demo() {
    let queue = DispatchQueue.global()
    //创建信号量  值为1  意思是最大并发数为1，任务只能一个接一个执行
    let semaphore = DispatchSemaphore.init(value: 1)
    
    //此时信号量为1，无需等待，向下执行 信号量 1->0
    semaphore.wait()
    queue.asyncAfter(deadline: .now() + 4) {
        print("1111")
        //延迟4秒后输出1111，释放信号量，信号量 从0->1
        semaphore.signal()
    }
    
    //延迟4秒输出1111后，此时信号量为1，继续向下执行  同上操作。。。
    semaphore.wait()
    queue.asyncAfter(deadline: .now() + 10) {
        print("2222")
        semaphore.signal()
    }
    
    semaphore.wait()
    queue.asyncAfter(deadline: .now() + 2) {
        print("3333")
        semaphore.signal()
    }
    
    semaphore.wait()
    queue.asyncAfter(deadline: .now() + 1) {
        print("4444")
        semaphore.signal()
    }
    
    semaphore.wait()
    queue.asyncAfter(deadline: .now() + 6) {
        print("5555")
        semaphore.signal()
    }
    
    semaphore.wait()
    print("任务全部完成")
    semaphore.signal()
}

输出：