【译】GCD并发队列(GCD Concurrent Queues)

来源:转载





这是GCD介绍的第三篇文章。


如果说串行队列可以很好的替代互斥锁,那么并发队列就可以很好的替代多线程。


并发队列允许你入队多个block,并且它们的执行不需要等待前一个block执行结束才开始。


运行下面这段程序几次:


#import <Foundation/Foundation.h>
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 <Foundation/Foundation.h>
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 <Foundation/Foundation.h>
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(把heshe改成“Don”和“Alice”)保证了对数据修改这一操作的原子性。因为障碍队列运行时不会被其他block中断或打扰,所以你永远不会看见“Luke likes Alice!”打印在你的控制台。


恭喜!你现在对并发队列有了一定的了解,知道了如何用它取代多线程,以及如何利用它创建一个高效的读写锁。在下一篇文章中,我们将研究一下全局并发队列和目标队列,下次见!




分享给朋友:
您可能感兴趣的文章:
随机阅读: