05GCD高级用法

GCD用的比较多的方法，
高级用法
注意事项

目的：实现一件事情做完，再做下一件事情，确保函数的执行周期。

GCD 的核心是分派队列。不论在 iOS 还是 Max OS X 分派队列,正如我们看到的是由位于主操作系统的 GCD 来管理的线程池。你不会直接与线程有工作关系。你只在分派队列上工作,将任务分派到这个队列上并要求队列来调用你的任务。GCD 为运行任务提供了几个选择:同步执行、异步执行和延迟执行等。

两种解决方案

1、创建barrier等待线程

dispatch_async(dispatch_get_main_queue(), ^{
        [self ActionFirst];
});
dispatch_barrier_async(dispatch_get_main_queue(), ^{
        [self ActionNext];
});

2、创建group线程组（即队列queue）

dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_main_queue(), ^{

       [self ActionFirst];
});

dispatch_group_notify(group, dispatch_get_main_queue(), ^{

        [self ActionNext];

});

出现问题的代码如下：

-（void）example
{
    [self ActionFirst];
    [self ActionNext];
}

产生原因：调用example函数时，由于ActionFirst函数执行的时间比较长，ActionNext函数执行比较快，当ActionNext函数执行完时，ActionFirst可能还没有执行完，导致执行ActionNext时出现崩溃的现象。

第二套方案

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