swift详解之十七-----------GCD的一些高级用法

GCD的一些高级用法

注：本小节总结几个GCD的高级用法

1、Dispatch Groups（调度组）

Dispatch Group 会在整个组的任务都完成时通知你，这些任务可以是同步的，也可以是异步的，即便在不同的队列也行。对多个异步任务的完成进行监控的问题。这无疑是一个非常好的选择

因为被监控的任务可能在不同的队列，因此用一个 dispatch_group_t 的实例来记下这些不同的任务。

当组中所有的事件都完成时，GCD 的 API 提供了两种通知方式。

第一种是 dispatch_group_wait ，它会阻塞当前线程，直到组里面所有的任务都完成或者等到某个超时发生。

因为你在使用的是同步的 dispatch_group_wait ，它会阻塞当前线程，所以你要用 dispatch_async 将整个方法放入后台队列以避免阻塞主线程。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)) {
            let group = dispatch_group_create(); //创建一个dispatch_group
            //dispatch_group_enter 手动通知 Dispatch Group 任务已经开始。你必须保证 dispatch_group_enter 和 dispatch_group_leave 成对出现，否则你可能会遇到诡异的崩溃问题。
            dispatch_group_enter(group)

            //.....
            print("ssss")

            dispatch_group_leave(group)

            dispatch_group_wait(group,DISPATCH_TIME_FOREVER); //一直等待

            dispatch_async(dispatch_get_main_queue(),{
                //刷新UI
            })
        }

首先创建一个group ，然后是执行groupenter 和 leave 中间的代码 。然后再利用dispatch_group_wait 让线程阻塞在这里 一直等待。最后再去执行刷新UI或者处理group结果的部分

然而，用阻塞线程这种方法显得不是name友好 。我们来看看第二种 ，不阻塞线程的方法 dispatch_group_notify

let groupDown = dispatch_group_create()
        dispatch_group_enter(groupDown)

        //....

        dispatch_group_leave(groupDown)

        dispatch_group_notify(groupDown,dispatch_get_main_queue()) {
                //回调
        }

dispatch_group_notify 以异步的方式工作。当 Dispatch Group 中没有任何任务时，它就会执行其代码

还有一种写法

let group1 = dispatch_group_create()
        dispatch_group_async(group1,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)) {
            //并行执行的线程1
        }
        dispatch_group_async(group1,0)) {
            //并行执行的线程2
        }
        dispatch_group_notify(group1,dispatch_get_main_queue()) {
            //回调 汇总结果。这里如果不涉及UI 也可以使用dispatch_get_global_queue
        }

一般情况下我们是会这么使用的

2、dispatch_apply

dispatch_apply 表现得就像一个 for 循环，但它能并发地执行不同的迭代。这个函数是同步的，所以和普通的 for 循环一样，它只会在所有工作都完成后才会返

当在 闭包 内计算任何给定数量的工作的最佳迭代数量时，必须要小心，因为过多的迭代和每个迭代只有少量的工作会导致大量开销以致它能抵消任何因并发带来的收益。而被称为跨越式（striding）的技术可以在此帮到你，即通过在每个迭代里多做几个不同的工作。
注意并发的开销。

dispatch_apply不适合用于串行队列，对于并发循环来说是很好选择，特别是当你需要追踪任务的进度时

下面来看一段使用的代码

dispatch_apply(3,0)) { (i:Int) -> Void in
                print(i)  //1,2,0  这里是异步的 每次输出的次序不一定相同  如果每次都会等待网络请求 可以这么搞

        }