swift GCD的简单使用

• 回到主线程

        DispatchQueue.main.async {
           //            print("这里是主线程")
        }

• 延时执行

        let deadline = DispatchTime.now() + 5.0
        DispatchQueue.global().asyncAfter(deadline: deadline) {
            //            print("这里是延迟做的事情")
        }

• 开启一个异步线程

        DispatchQueue.main.async {
            print("开新异步线程执行")
        }

•  开启一个同步线程

DispatchQueue.global().sync {
            
}

•  线程优先级

        var queue: DispatchQueue = DispatchQueue.global()//
        //DispatchQueue.GlobalQueuePriority 有四中选择 high，`default`，low，background
        queue = DispatchQueue.global(priority: DispatchQueue.GlobalQueuePriority.background)// 后台执行
        // 异步执行队列任务
        queue.async {
            //  print("开新线程执行")
        }

•  分组执行

       let group = DispatchGroup()
        queue = DispatchQueue.global(priority: DispatchQueue.GlobalQueuePriority.default)// 默认优先级执行
        for i in 0 ..< 10 {
            //异步执行队列任务
            queue.async(group: group, execute: {
                print("queue.async(group: group (i)")
            })
        }
        // 分组队列执行完毕后执行
        group.notify(queue: queue) {
            print("dispatch_group_notify")
        }

• 串行队列：只有一个线程，加入到队列中的操作按添加顺序依次执行。

       let serialQueue = DispatchQueue(label: "yangj", attributes: [])
        for i in 0 ..< 10 {
            //异步执行队列任务
            serialQueue.async {
                print("serialQueue.async (i)")
            }
        }

• 并发队列：有多个线程，操作进来之后它会将这些队列安排在可用的处理器上，同时保证先进来的任务优先处理。

        let globalQueue = DispatchQueue.global(priority: DispatchQueue.GlobalQueuePriority.default)
        for i in 0 ..< 10 {
            //异步执行队列任务
            globalQueue.async {
                print("globalQueue.async (i)")
            }
        }

•  信号量

       //DispatchSemaphore 因为信号量值为1，所以一次只能执行一个
        let semaphore = DispatchSemaphore(value: 1)
        let queue = DispatchQueue.global()
        queue.async {
            semaphore.wait()
            let deadline = DispatchTime.now() + 3.0
            DispatchQueue.global().asyncAfter(deadline: deadline) {
                print("-----------------1");
                semaphore.signal()
            }
            
        }
        queue.async {
            semaphore.wait()
            let deadline = DispatchTime.now() + 10.0
            DispatchQueue.global().asyncAfter(deadline: deadline) {
                 print("-----------------2");
                 semaphore.signal()
            }
            
        }
        queue.async {
            semaphore.wait()
            let deadline = DispatchTime.now() + 2.0
            DispatchQueue.global().asyncAfter(deadline: deadline) {
                print("-----------------3");
                semaphore.signal()
            }
            
        }

• oc中dispatch_group_enter的使用

        // 创建调度组
        let workingGroup = DispatchGroup()
        // 创建多列
        let workingQueue = DispatchQueue(label: "request_queue")
        
        // 模拟异步发送网络请求 A
        // 入组
        workingGroup.enter()
        workingQueue.async {
            Thread.sleep(forTimeInterval: 1)
            print("接口 A 数据请求完成")
            // 出组
            workingGroup.leave()
        }
        
        // 模拟异步发送网络请求 B
        // 入组
        workingGroup.enter()
        workingQueue.async {
            Thread.sleep(forTimeInterval: 1)
            print("接口 B 数据请求完成")
            // 出组
            workingGroup.leave()
        }
        
        print("我是最开始执行的，异步操作里的打印后执行")
        
        // 调度组里的任务都执行完毕
        workingGroup.notify(queue: workingQueue) {
            print("接口 A 和接口 B 的数据请求都已经完毕！, 开始合并两个接口的数据")
        }