Swift3 GCD的基本用法（二） - 队列的循环/挂起/恢复、其他常用

接上一篇：Swift3 GCD的基本用法（一） - 任务和队列、服务优先级、信号量

本文代码：https://github.com/NinoWang/MultithreadingDemo/tree/master

队列的循环、挂起、恢复

// 循环
    func dispatchApply() {
        DispatchQueue.global().async {
            DispatchQueue.concurrentPerform(iterations: 10,execute: { (index) in
                print("this is NO.(index),thread=(Thread.current)")
            })
            
            DispatchQueue.main.async {
                print("Done")
            }
        }
    }
    
    // 挂起和恢复
    func suspendAndResume() {
        // 先挂起显示结果的任务 图片下载完成后恢复
        print("开始任务")
        let globalQueue = DispatchQueue(label: "ShowResult")
        globalQueue.suspend()
        globalQueue.async {
            print("图片下载完成")
        }
        
        let concurrentQueue = DispatchQueue(label: "Concurrent",attributes: .concurrent)
        concurrentQueue.async {
            if let url = URL.init(string: "https://placebeard.it/800/800") {
                do {
                    print("正在下载，请稍后...")
                    _ = try Data(contentsOf: url)
                    
                    DispatchQueue.main.async {
                        globalQueue.resume()
                    }
                } catch {
                    print(error)
                }
            }
        }
    }

GCD的其他方法

final class SingleTon: NSObject {
    static let shared = SingleTon()
    private override init() {}
    
    func func1() {
        print("单例中的 function")
    }
}

注：final关键字的作用是这个类或方法不希望被继承和重写

// 只执行一次
    func runOnce() {
        SingleTon.shared.func1()
    }
    
    // asyncAfter DispatchTime 延时执行
    func delayDispatchTime() {
        print("开始执行(NSDate())")
        // asyncAfter 并不是在指定时间后执行任务处理，而是在指定时间后把任务追加到queue里面。因此会有少许延迟。注意，我们不能（直接）取消我们已经提交到 asyncAfter 里的代码。
        // dispatch_time用于计算相对时间,当设备睡眠时，dispatch_time也就跟着睡眠了,let time: DispatchTimeInterval = .seconds(3)
        DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + time,execute: {
            print("相对延时3秒后执行(NSDate())")
        })
    }
    
    // asyncAfter DispatchWallTime 延时执行
    func deplyDispatchWallTime() {
        print("开始执行(NSDate())")
        
        let walltime = DispatchWallTime.now() + 3.0
        
        //wallDeadline需要一个DispatchWallTime类型。创建DispatchWallTime类型，需要timespec的结构体。
        DispatchQueue.global().asyncAfter(wallDeadline: walltime) {
            print("绝对延时3秒后执行(NSDate())")
        }
    }
    
    // 任务组
    func queueGroup() {
        let globalQueue = DispatchQueue.global()
        let group = DispatchGroup()
        
        globalQueue.async(group: group,execute: {
            print("执行任务1")
        })
        
        globalQueue.async(group: group,execute: {
            print("执行任务2")
        })
        
        globalQueue.async(group: group,execute: {
            print("执行任务3")
        })
        
        globalQueue.async(group: group,execute: {
            print("执行任务4")
        })
        
        group.notify(queue: globalQueue) {
            print("任务全部完成")
        }
    }