【翻译】Why GCD?

2016-08-07 本文已影响780人知识小集

原文发表于humancode.us，地址是：Why GCD?。由我们团队的小王子童鞋翻译完成。该文已得到原文作者的翻译许可。

小王子童鞋自己在简书上开了一个博客，本文也可以在其博客上看到。

这是关于GCD介绍系列的第一篇文章。

一句话概括：更好的并行。

在过去的10年中，CPU的速度提升遇到了瓶颈，为了获得更强的性能，CPU的制造商在他们的产品中加入越来越多的核心（我的MacBook Pro是8核的并且它一天二十四小时都在运行）

CPU运算速度

问题是，我们的程序并不能从这些额外的核心中获得益处，除非它知道如何高效的分发任务给这些核心。

用并行的思想来处理这个问题就是同时处理多个任务。这实现起来并不简单，不过GCD让这件事变得简单可控。

你不必写一大堆实现并行的代码，直接使用GCD实现它，让你的UI和网络请求不再需要等待任务完成之后才去执行，从而使你的程序变得响应更快。

不过在那之前，让我们先看一看在使用GCD应该先做哪些功课。

线程

传统的实现并行的方式就是使用线程。在一个多核的计算机中，每一个新的线程可以被分配给不同的核心去执行。多个核心同时运行不同的线程，这就实现了并行。

单核的情况下，这个核心会定期的抢占一个正在运行的线程的资源，从而让其他线程得以运行。这就给人一种错觉好像是并行执行的。

但是使用线程来实现并行也就意味着你将面临一些问题。把数据传入一个线程和从中取出通常不太简单，把控制和信号从一个线程传到另一个线程也并不容易。对于那些在一个高度并行的系统中要被执行的若干任务，要想算出究竟应该创建多少个线程也是个问题。

由于创建和销毁线程是一个开销相对较大的任务，所以很多多线程的程序会创建一个线程池。这个线程池也将有你来管理，这将加大你程序的复杂度。

同步

当你有许多线程需要运行，你肯定会遇到一个典型的问题——竞态条件(race conditions)，即最终的计算结果是不确定的，取决于这些线程的执行顺序。

一个典型的竞态条件例子就是“银行账户问题”：

@interface BankAccount: NSObject
@property (nonatomic, assign) double balance;
@end

// ...

// Create an account holding $100
BankAccount *account = [[BankAccount alloc] init];
account.balance = 100;

// ...

// Thread 1 - withdraw $10
void thread1() {
    double balance = account.balance;
    account.balance = balance - 10;
}

// ...

// Thread 2 - accrue 10% interest
void thread2() {
    double balance = account.balance;
    account.balance = balance * 1.10;
}

// account.balance = ?

账户最后的余额取决于这些语句在这2个线程中的执行顺序(记住，这些线程是同时执行的)。

假设这些线程只能被上面这些语句所占用，那么这一段代码有可能出现多少种结果？这些值又是多少？

竞态条件在单核的设备上也有可能出现

这类问题的传统解决办法就是采用同步对象。典型的同步对象包括以下几个：

信号量(Semaphore) - 只运行一定的资源被使用，线程必须等待直到有可用的资源。
互斥锁(Mutual Exclusion) - 同一时间只允许一个线程被执行，当一个线程有互斥锁时，别的线程必须等待。
条件变量(Condition Variable) - 线程必须等待某些条件变成true才能执行

队列，队列，队列

GCD解决了线程管理和同步的问题，并且从头开始采用了一个新的抽象化概念：队列。

简单来说，队列是一种确保串行执行其中任务的数据结构。一个程序可以创建多个队列，同时这些队列能够相对彼此并行地执行任务，而每个队列中的任务将会被顺序执行。

队列相对于多线程有着明显的优势。首先，线程将由CGD库来管理，队列会被按需分配给线程，线程没有被使用时将可能会被释放。其次，GCD库可以向系统咨询，什么时候创建多少线程是最合适的。最后，因为队列只有在它需要时才会去创建线程，所以队列的开销很小。一个程序可以有几十个队列也不会使得其资源紧张。

总之：队列给你提供了线程的优点，却不需要你去考虑线程的管理。

在CGD中有三种类型的队列：

串行队列(Serial) - 按照任务加入队列的顺序，同一时间只执行一个任务。一个任务开始执行之前，其前面一个任务必须执行完成。
并发队列(Concurrent) - 也是按照任务加入队列的顺序执行任务，但是每一个任务是并发的执行，后面任务执行也不需要等待前一个任务的结束才开始。
主队列(Mian) - 一个在主线程中预先创建好的串行队列，这个队列可以和NSRunLoop进行交互，你的程序通常是在这个队列中开始执行。

Blocks

一般以向队列中加入block的方式来使用队列。

你也可以把函数调用加入队列中，但是这一系列的文章将会聚焦在GCD的block相关的API上。

Block是一个能捕捉其上下文的代码块，这里有一个例子：

#import <Foundation/Foundation.h>

typedef void(^Block)();

Block printer(NSString *string) {
    return ^{
        NSLog(@"%@", string);
    };
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Block a = printer(@"Hello");
        Block b = printer(@"World");

        a(); // prints "Hello"
        b(); // prints "World"
        a(); // prints "Hello" again
    }
    return 0;
}

在上面的例子中，printer()返回一个带有string参数的block，每一次这个block被调用，block里的代码就会拿着这个block创建时赋值给这个参数的值去执行。

Hello, Dispatch World!

现在我们准备好了一切，去使用GCD写出我们的第一个"Hello World"程序。如下：

#import <Foundation/Foundation.h>

int main() {
    // Enqueue two blocks on the main queue.
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"Hello");
    });
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"World");
    });

    // Nothing is printed yet because we are also running in the main queue.

    dispatch_main(); // Print "Hello" "World".
    return -1; // Never called.
}

让我们看看这一段代码是怎么工作的：

dispatch_async()的调用告诉GCD去入队一个block，然后继续往下执行而并不需要等待block里的代码执行完。我们调用了两次dispatch_async()，也就是说将两个block加入了主队列中。

注意这时候程序自己就在主队列中运行着（主队列在程序运行之前就存在了，main()通常就在主队列中被执行），所以没有任何东西被打印出来。入队的这两个block会在main()之后被调用。

为了执行主队列中的其它block，我们调用了dispatch_main()，这会暂停main()中的初始化工作，然后执行加入主队列中的其它blcok。首先，打印“Hello”的block被执行，这个block执行完后，下一个block将会被执行，它打印出了“World“。

如果你的程序使用了基础类库(Foundation classes)，你最好用[[NSRunLoop currentRunLoop] run]代替dispatch_main()，因为后者不支持 run loop sources ，比如NSTimer

当主队列执行完毕，dispatch_main()只是被闲置，程序并不会终止！如果你想让你的程序运行完之后就终止，你必须把exit(0)的操作加入队列中，试试吧！

恭喜！你已经写下了你的第一个GCD程序，在下一篇中，我们将讨论一下如何以同步的方式使用队列。

【翻译】Why GCD?

线程

同步

队列，队列，队列

Blocks

Hello, Dispatch World!

猜你喜欢

热点阅读