GCD你应该知道的事儿

写在最前边，这边文章适合刚入行或者对GCD不是很了解的同学阅读，大神请略过~~~~~~

为何要写这篇文章呢？

最近看了好多iOS简历，在专业技能上都会写有这么一条** “熟悉NSThread、NSOperation、GCD等多线程开发技术” **，看到这里我都会问同一个问题，就是 “你对其中哪种技术最熟悉，或者用的最多”，99%的面试者给出的答案都是GCD。进一步询问使用情况的时候，大多数面试者都会给出比较简单的答案。

dispatch_async(dispatch_get_global_queue(0, 0), ^{
//执行耗时操作
……
dispatch_async(dispatch_get_main_queue(), ^{
//回到主线程进行UI刷新操作
};
};

然后就基本没有然后了。这篇文章我会针对GCD一些常用的方法做一下简要分析（太复杂的方法我也不会~~~），希望能对刚入行的同学们有一定的帮助。

串行 & 并行

GCD中dispatch_queue大致可以分为三类

1. 全局的并行的queue
2. 主线程的串行的queue
3. 自定义的queue

全局的queue和主线程的queue结合使用（上边提到的）就是我们平常最常用的一种用法，在异步线程中执行耗时操作，然后在UI线程执行刷新操作。
全局的queue我们可以通过dispatch_get_global_queue(0, 0)直接获取，这里有两个参数，第一个表示线程执行的优先级（第二个参数是预留参数暂时没有什么鸟用），什么意思呢？当我们通过dispatch_async(globalQueue, ^{}); 这种方式去异步执行一个操作时，实际上操作系统会创建一个新的线程，当我们同时执行多个这样的操作时，我们如何能保证哪个线程先执行呢？这时候这个参数就派上了用场。这个参数一共可以有四个值：

#######define DISPATCH_QUEUE_PRIORITY_HIGH 2
#######define DISPATCH_QUEUE_PRIORITY_DEFAULT 0
#######define DISPATCH_QUEUE_PRIORITY_LOW (-2)
#######define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN

</code>
下面来看一段代码，我们设置默认值0

dispatch_async(dispatch_get_global_queue(0, 0), ^{
    NSLog(@"start task 1");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 1");
});   
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    NSLog(@"start task 2");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 2");
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    NSLog(@"start task 3");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 3");
});

第一个参数默认都设成0

接下来我们加入优先级的参数，再来看一下结果

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
    NSLog(@"start task 1");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 1");
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
    NSLog(@"start task 2");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 2");
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"start task 3");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 3");
});

带有优先级参数

结果很明显已经完全按照我们的优先级进行执行的

DISPATCH_QUEUE_PRIORITY_HIGH>DISPATCH_QUEUE_PRIORITY_DEFAULT>DISPATCH_QUEUE_PRIORITY_LOW

相信大家已经明白第一个参数的作用了吧，如果你的需求需要某个并发线程先执行，可以通过设置优先级来达到目的，但是因为线程是并发执行的，所以你不能保证哪个线程会先执行完，也就是不能保证我们的耗时任务是按照顺序执行的。
那么如何才能保证按顺序执行呢？这就需要我们自定义串行的queue来解决，系统为我们提供了这个方法dispatch_queue_create(const char *label, dispatch_queue_attr_t attr)，这个方法同样也有两个参数，第一个参数是确定唯一queue的一个标识，第二个参数创建queue的类型，串行的还是并行的。下面看一个例子：

/**
 *  我们创建了一个串行的queue
 *
 *  @param "com.gcd.test.queue"  唯一标识这个queue
 *  @param DISPATCH_QUEUE_SERIAL 说明是串行的queue
 */
dispatch_queue_t myQueue = dispatch_queue_create("com.gcd.test.queue", DISPATCH_QUEUE_SERIAL);

dispatch_async(myQueue, ^{
    NSLog(@"start task 1");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 1");
});

dispatch_async(myQueue, ^{
    NSLog(@"start task 2");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 2");
});

dispatch_async(myQueue, ^{
    NSLog(@"start task 3");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 3");
});

串行队列执行结果

有两点需要注意的地方，第一，串行queue严格按照顺序执行耗时任务。第二，GCD在执行串行queue时，其实是在一个线程中完成的，这样就会严格的按照顺序进行执行了，如上图中红色部分，42565是主线程ID， 1589679就是我们的异步线程ID。而在并发的queue中，我们会发现线程ID都是不一样的，说明是多个线程。
如果我们在queue的创建时dispatch_queue_t myQueue = dispatch_queue_create("com.gcd.test.queue", DISPATCH_QUEUE_SERIAL)，我们把参数DISPATCH_QUEUE_SERIAL变成DISPATCH_QUEUE_CONCURRENT，将会创建一个并发的queue，此处的结果和global_queue无异，这里不在赘述。

dispatch_group_queue

GCD另一个比较常用的方法就是dispatch_group_queue，
在我们平时实际项目中经常会有这样的需求，就是在多个任务异步处理后我们需要一个统一的回调通知去处理接下来的业务，这个时候我们就想到了dispatch group了，当所有任务完成后会调用dispatch_group_notify，来看一个例子：

/**
 *  创建一个并发的queue
 */
dispatch_queue_t queue = dispatch_queue_create("com.test.gcd.queue", DISPATCH_QUEUE_CONCURRENT);
/**
 *  创建一个group
 */
dispatch_group_t group = dispatch_group_create();
/**
 *  执行3个耗时任务
 */
dispatch_group_async(group, queue, ^{
    NSLog(@"start task 1");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 1");
});

dispatch_group_async(group, queue, ^{
    NSLog(@"start task 2");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 2");
});

dispatch_group_async(group, queue, ^{
    NSLog(@"start task 3");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 3");
});
dispatch_group_notify(group, queue, ^{
    NSLog(@"task over");
});

执行结果

当三个异步耗时操作完成后，统一一个回调，两点注意：

1. 回调回来的数据异步线程中，这一点通过它前边的线程ID号1631915就能发现。所以如果后续执行刷新UI操作需要到主线程中完成。
2. 接收回调的这个线程就是任务最后执行完的那个线程，系统做了优化并没有多开一个线程来处理。

结合实际场景，很多同学比较容易犯一个错误，假如我们有两个请求需要同时发送，并统一回调，很多同学这时候就会想到了dipatch_group。

dispatch_queue_t queue = dispatch_queue_create("com.test.gcd.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group, queue, ^{
    [self sendRequest1:^{
    }];
});

dispatch_group_async(group, queue, ^{
    [self sendRequest2:^{
    }];
});

dispatch_group_notify(group, queue, ^{
    NSLog(@"task over");
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"refresh ui");
    });
});

- (void)sendRequest1:(void(^)())block {
//异步请求，请求结果后block回调
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    NSLog(@"start task 1");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 1");
    dispatch_async(dispatch_get_main_queue(), ^{
        if (block) {
            block();
        }
    });
});
}
- (void)sendRequest2:(void(^)())block {
//异步请求，请求结果后block回调
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    NSLog(@"start task 2");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"end task 2");
    dispatch_async(dispatch_get_main_queue(), ^{
        if (block) {
            block();
        }
    });
});
}

其中sendRequest1和sendRequest2是两个异步请求，可以简单理解为我们的业务请求API，我们最初的设想是task1和task2完成后统一回调回来，但结果确实这样：

运行结果

这是为什么呢？很明显应为sendRequest1和sendRequest2都是异步请求API，所以dispatch_group_async中瞬间就执行完了。肿么办？难道针对这种需求就没有办法了吗？当然有，dispatch_group还有一个办法能很好的解决这个问题，就是dispatch_group_enter() & dispatch_group_leave这对组合。我们把这个需求重新实现一下：

dispatch_group_t group = dispatch_group_create();

dispatch_group_enter(group);
[self sendRequest1:^{
    dispatch_group_leave(group);
}];

dispatch_group_enter(group);
[self sendRequest2:^{
    dispatch_group_leave(group);
}];

dispatch_group_notify(group, queue, ^{
    NSLog(@"task over");
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"refresh ui");
    });
});

运行结果

这下就对了，完全按照我们的想法去执行了。
dispatch_group_enter() 和 dispatch_group_leave()必须成对出现，group_enter是将请求任务放入到group后，便一直被group持有，直到碰到group_leave；才会释放出来，只有group中不在持有任何任务后才会调用notify进行回调通知。

文章写到这里基本已经接近尾声了，当然GCD还有很多其他用法，常用的比如dispatch_once、dispatch_after、dispatch_barrier等等，本篇文章就不在做详细说明。希望以上的内容能对正在阅读的你有所帮助。