这是GCD介绍的第三篇文章。
如果说串行队列可以很好的替代互斥锁，那么并发队列就可以很好的替代多线程。
并发队列允许你入队多个block，并且它们的执行不需要等待前一个block执行结束才开始。
运行下面这段程序几次：
#import
void print(int number) {
for (int count = 0; count < 10; ++count) {
NSLog(@"%d", number);
}
}
int main(int argc, const char * argv[]) {
dispatch_queue_t queue = dispatch_queue_create("My concurrent queue", DISPATCH_QUEUE_CONCURRENT);
@autoreleasepool {
for (int index = 0; index < 5; ++index) {
dispatch_async(queue, ^{
print(index);
});
}
}
dispatch_main();
return 0;
}
dispatch_async()告诉GCD去入队一个block，但是不用等待这个block执行完毕才继续接下来的操作。这就允许我们可以快速一次把5个block入队到我们刚才创建的队列中。
当第一个block被入队时，队列还是空的，和串行队列一样这个block会立即开始执行。然而，第二个block入队之后也会立即执行，即使第一个block还没执行完毕，第三个，第四个，第五个block也是如此，它们会一起开始执行。
每一个入队的blcok在创建的时候获取了一个
index值，然后将这个值打印10次。程序的输出结果如你所料吗？为什么每次运行输出的结果都不一样？
如果我们把并发队列换成串行队列结果会怎么样呢？试试吧！把
DISPATCH_QUEUE_CONCURRENT换成DISPATCH_QUEUE_SERIAL，然后再运行看看。
用队列，不用线程
你可能没注意到，上面的程序在完全不用pthread_create()或NSThread的情况下，轻松得创建的5个线程。因为并发队列中的每一个block需要同时运行，所以GCD会为每一个block自动的创建（或抢占）一个线程来执行它们，一旦有某一个block执行完毕，它对应的线程就会被销毁或者放回线程池中。使用GCD，你只需要关心队列，让GCD库去关心线程的事。
虽然你不用手动去管理线程，但是你还是不能忽略线程的限制。如果你的入队的block数量超过了进程中的可用线程数，你的程序将会终止运行，而这通常是没有预警的。
障碍（Barriers）
这时自然会有一个问题产生：既然并发队列允许所有的block一起执行，那为什么它还叫“队列”呢？它不是更像一个可以加入并行执行block的堆吗？
当你考虑到障碍(Barriers)的时候，并发队列看起来就像一个”队列“了。加入障碍(Barriers)之后，你通过dispatch_barrier_sync()和dispatch_barrier_async()入队的block会发生一些有趣的事：这个障碍block（译者注：障碍也是以block的形式加入队列中的）将会被入队，但是不会立即执行，而是会等到在它之前入队的队列执行完毕之后才会开始执行。另外，所有在障碍block之后入队的block会等到障碍block本身执行完毕之后才会执行。可以把障碍block看做是一个“瓶颈”，在一系列并行执行的操作中，强制串行执行。
下面这段程序展示了的屏障(Barriers)的作用：
#import
void print(int number) {
for (int count = 0; count < 10; ++count) {
NSLog(@"%d", number);
}
}
int main(int argc, const char * argv[]) {
dispatch_queue_t queue = dispatch_queue_create("My concurrent queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_suspend(queue); // Suspend the queue so blocks are enqueued, but not executed
@autoreleasepool {
// Enqueue five blocks
for (int index = 0; index < 5; ++index) {
dispatch_async(queue, ^{
print(index);
});
}
// Enqueue a barrier
dispatch_barrier_async(queue, ^{
NSLog(@"--- This is a barrier ---");
});
// Enqueue five more blocks
for (int index = 5; index < 10; ++index) {
dispatch_async(queue, ^{
print(index);
});
}
}
dispatch_resume(queue); // Go!
dispatch_main();
return 0;
}
运行一下这段程序，注意到在障碍之前，只有index为0到4的block执行了，而在障碍之后，只有index为5到9的block执行了。但是在障碍前后的单独一边，5个block是同时执行的。
读写锁（Readers-Writer Locks）
在我之前的文章中，我介绍了如何使用串行队列保护数据变量以防止竞态条件的发生。这种方法使得同一时间只有一个线程访问变量，保证了操作的原子性。
但是实际上，在同步执行的操作中我们不用做任何事来防止静竞态条件的发生，我们需要做的是防止数据被异步的改变，而多个线程同时访问而不改变同一份数据是被允许的(从性能的角度讲，这也应该是较好的做法)。
这时我们就需要一个读写锁(readers-writer lock)，它的功能是允许对数据读的操作可以是并行同时发生的，但是写的操作必须是串行的。
使用异步队列和障碍，我们可以轻松的实现一个读写锁，这里有一个例子：
#import
dispatch_queue_t queue;
NSString *he = @"Luke";
NSString *she = @"Megan";
void printAndRepeat() {
NSLog(@"%@ likes %@!", he, she);
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), queue,
// This block is dispatch_async'd to the concurrent queue after 1 second
^{
printAndRepeat();
});
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
queue = dispatch_queue_create("Reader-writer queue", DISPATCH_QUEUE_CONCURRENT);
// Create readers
for (int index = 0; index < 5; ++index) {
dispatch_async(queue, ^{
printAndRepeat();
});
}
// Change the variables after 5 seconds
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(),
// This block is enqueued onto the main queue after 5 seconds.
^{
dispatch_barrier_async(queue, ^{
he = @"Don";
she = @"Alice";
});
});
}
dispatch_main();
return 0;
}
你目前可以先忽略
dispatch_after()的调用，它只是简单的告诉GCD在一段时间后入队一个block。
在这个例子中，障碍block(把he和she改成“Don”和“Alice”)保证了对数据修改这一操作的原子性。因为障碍队列运行时不会被其他block中断或打扰，所以你永远不会看见“Luke likes Alice!”打印在你的控制台。
恭喜！你现在对并发队列有了一定的了解，知道了如何用它取代多线程，以及如何利用它创建一个高效的读写锁。在下一篇文章中，我们将研究一下全局并发队列和目标队列，下次见！