程序博客网 > 查找算法效率

GCD

来源：互联网 发布：查找算法效率 编辑：程序博客网 时间：2024/06/11 09:54

什么是GCD

Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法。该方法在Mac OS X 10.6雪豹中首次推出，并随后被引入到了iOS4.0中。GCD是一个替代诸如NSThread, NSOperationQueue, NSInvocationOperation等技术的很高效和强大的技术，它看起来象就其它语言的闭包(Closure)一样，但苹果把它叫做blocks。

应用举例

让我们来看一个编程场景。我们要在iphone上做一个下载网页的功能，该功能非常简单，就是在iphone上放置一个按钮，点击该按钮时，显示一个转动的圆圈，表示正在进行下载，下载完成之后，将内容加载到界面上的一个文本控件中。

不用GCD前

虽然功能简单，但是我们必须把下载过程放到后台线程中，否则会阻塞UI线程显示。所以，如果不用GCD, 我们需要写如下3个方法：

  • someClick 方法是点击按钮后的代码，可以看到我们用NSInvocationOperation建了一个后台线程，并且放到NSOperationQueue中。后台线程执行download方法。
  • download 方法处理下载网页的逻辑。下载完成后用performSelectorOnMainThread执行download_completed 方法。
  • download_completed 进行clear up的工作，并把下载的内容显示到文本控件中。

这3个方法的代码如下。可以看到，虽然 开始下载 -> 下载中 -> 下载完成 这3个步骤是整个功能的三步。但是它们却被切分成了3块。他们之间因为是3个方法，所以还需要传递数据参数。如果是复杂的应用，数据参数很可能就不象本例子中的NSString那么简单了，另外，下载可能放到Model的类中来做，而界面的控制放到View Controller层来做，这使得本来就分开的代码变得更加散落。代码的可读性大大降低。

  1. static NSOperationQueue * queue; 
  2.  
  3. - (IBAction)someClick:(id)sender { 
  4.     self.indicator.hidden = NO; 
  5.     [self.indicator startAnimating]; 
  6.     queue = [[NSOperationQueue alloc] init]; 
  7.     NSInvocationOperation * op = [[[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download) object:nil] autorelease]; 
  8.     [queue addOperation:op]; 
  9. } 
  10.  
  11. - (void)download { 
  12.     NSURL * url = [NSURL URLWithString:@"http://www.youdao.com"]; 
  13.     NSError * error; 
  14.     NSString * data = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:&error]; 
  15.     if (data != nil) { 
  16.         [self performSelectorOnMainThread:@selector(download_completed:) withObject:data waitUntilDone:NO]; 
  17.     } else { 
  18.         NSLog(@"error when download:%@", error); 
  19.         [queue release]; 
  20.     } 
  21. } 
  22.  
  23. - (void) download_completed:(NSString *) data { 
  24.     NSLog(@"call back"); 
  25.     [self.indicator stopAnimating]; 
  26.     self.indicator.hidden = YES; 
  27.     self.content.text = data; 
  28.     [queue release]; 
  29. } 

使用GCD后

如果使用GCD，以上3个方法都可以放到一起，如下所示：

  1. // 原代码块一 
  2. self.indicator.hidden = NO; 
  3. [self.indicator startAnimating]; 
  4. dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
  5.     // 原代码块二 
  6.     NSURL * url = [NSURL URLWithString:@"http://www.youdao.com"]; 
  7.     NSError * error; 
  8.     NSString * data = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:&error]; 
  9.     if (data != nil) { 
  10.         // 原代码块三 
  11.         dispatch_async(dispatch_get_main_queue(), ^{ 
  12.             [self.indicator stopAnimating]; 
  13.             self.indicator.hidden = YES; 
  14.             self.content.text = data; 
  15.         }); 
  16.     } else { 
  17.         NSLog(@"error when download:%@", error); 
  18.     } 
  19. }); 

首先我们可以看到，代码变短了。因为少了原来3个方法的定义，也少了相互之间需要传递的变量的封装。

另外，代码变清楚了，虽然是异步的代码，但是它们被GCD合理的整合在一起，逻辑非常清晰。如果应用上MVC模式，我们也可以将View Controller层的回调函数用GCD的方式传递给Modal层，这相比以前用@selector的方式，代码的逻辑关系会更加清楚。

GCD的定义

简单GCD的定义有点象函数指针，差别是用 ^ 替代了函数指针的 * 号，如下所示：

  1. // 申明变量 
  2.  (void) (^loggerBlock)(void); 
  3.  // 定义 
  4.  loggerBlock = ^{ 
  5.       NSLog(@"Hello world"); 
  6.  }; 
  7.  // 调用 
  8.  loggerBlock(); 

但是大多数时候，我们通常使用内联的方式来定义它，即将它的程序块写在调用的函数里面，例如这样：

  1. dispatch_async(dispatch_get_global_queue(0, 0), ^{ 
  2.      // something 
  3. }); 

从上面大家可以看出，block有如下特点：

  1. 程序块可以在代码中以内联的方式来定义。
  2. 程序块可以访问在创建它的范围内的可用的变量。

系统提供的dispatch方法

为了方便地使用GCD，苹果提供了一些方法方便我们将block放在主线程 或 后台线程执行，或者延后执行。使用的例子如下：

  1. //  后台执行： 
  2.  dispatch_async(dispatch_get_global_queue(0, 0), ^{ 
  3.       // something 
  4.  }); 
  5.  // 主线程执行： 
  6.  dispatch_async(dispatch_get_main_queue(), ^{ 
  7.       // something 
  8.  }); 
  9.  // 一次性执行： 
  10.  static dispatch_once_t onceToken; 
  11.  dispatch_once(&onceToken, ^{ 
  12.      // code to be executed once 
  13.  }); 
  14.  // 延迟2秒执行： 
  15.  double delayInSeconds = 2.0; 
  16.  dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC); 
  17.  dispatch_after(popTime, dispatch_get_main_queue(), ^(void){ 
  18.      // code to be executed on the main queue after delay 
  19.  }); 

dispatch_queue_t 也可以自己定义，如要要自定义queue，可以用dispatch_queue_create方法，示例如下：

  1. dispatch_queue_t urls_queue = dispatch_queue_create("blog.devtang.com", NULL); 
  2. dispatch_async(urls_queue, ^{ 
  3.      // your code 
  4. }); 
  5. dispatch_release(urls_queue); 

另外，GCD还有一些高级用法，例如让后台2个线程并行执行，然后等2个线程都结束后，再汇总执行结果。这个可以用dispatch_group, dispatch_group_async 和 dispatch_group_notify来实现，示例如下：

  1. dispatch_group_t group = dispatch_group_create(); 
  2. dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{ 
  3.       // 并行执行的线程一 
  4.  }); 
  5.  dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{ 
  6.       // 并行执行的线程二 
  7.  }); 
  8.  dispatch_group_notify(group, dispatch_get_global_queue(0,0), ^{ 
  9.       // 汇总结果 
  10.  }); 

修改block之外的变量

默认情况下，在程序块中访问的外部变量是复制过去的，即写操作不对原变量生效。但是你可以加上 __block来让其写操作生效，示例代码如下：

  1. __block int a = 0; 
  2. void  (^foo)(void) = ^{ 
  3.      a = 1; 
  4. } 
  5. foo(); 
  6. // 这里，a的值被修改为1 

后台运行

GCD的另一个用处是可以让程序在后台较长久的运行。在没有使用GCD时，当app被按home键退出后，app仅有最多5秒钟的时候做一些保存或清理资源的工作。但是在使用GCD后，app最多有10分钟的时间在后台长久运行。这个时间可以用来做清理本地缓存，发送统计数据等工作。

让程序在后台长久运行的示例代码如下：

  1. // AppDelegate.h文件 
  2. @property (assign, nonatomic) UIBackgroundTaskIdentifier backgroundUpdateTask; 
  3.  
  4. // AppDelegate.m文件 
  5. - (void)applicationDidEnterBackground:(UIApplication *)application 
  6. { 
  7.     [self beingBackgroundUpdateTask]; 
  8.     // 在这里加上你需要长久运行的代码 
  9.     [self endBackgroundUpdateTask]; 
  10. } 
  11.  
  12. - (void)beingBackgroundUpdateTask 
  13. { 
  14.     self.backgroundUpdateTask = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{ 
  15.         [self endBackgroundUpdateTask]; 
  16.     }]; 
  17. } 
  18.  
  19. - (void)endBackgroundUpdateTask 
  20. { 
  21.     [[UIApplication sharedApplication] endBackgroundTask: self.backgroundUpdateTask]; 
  22.     self.backgroundUpdateTask = UIBackgroundTaskInvalid; 
  23. } 

Dispatch Objects

尽管GCD是纯c语言的，但它被组建成面向对象的风格。GCD对象被称为dispatch object。Dispatch object像Cocoa对象一样是引用计数的。使用dispatch_release和dispatch_retain函数来操作dispatch object的引用计数来进行内存管理。但主意不像Cocoa对象，dispatch object并不参与垃圾回收系统，所以即使开启了GC，你也必须手动管理GCD对象的内存。

Dispatch queues 和 dispatch sources（后面会介绍到）可以被挂起和恢复，可以有一个相关联的任意上下文指针，可以有一个相关联的任务完成触发函数。可以查阅“man dispatch_object”来获取这些功能的更多信息。

Dispatch Queues

GCD的基本概念就是dispatch queue。dispatch queue是一个对象，它可以接受任务，并将任务以先到先执行的顺序来执行。dispatch queue可以是并发的或串行的。并发任务会像NSOperationQueue那样基于系统负载来合适地并发进行，串行队列同一时间只执行单一任务。

GCD中有三种队列类型：

  1. The main queue: 与主线程功能相同。实际上，提交至main queue的任务会在主线程中执行。main queue可以调用dispatch_get_main_queue()来获得。因为main queue是与主线程相关的，所以这是一个串行队列。
  2. Global queues: 全局队列是并发队列，并由整个进程共享。进程中存在三个全局队列：高、中（默认）、低三个优先级队列。可以调用dispatch_get_global_queue函数传入优先级来访问队列。
  3. 用户队列: 用户队列 (GCD并不这样称呼这种队列, 但是没有一个特定的名字来形容这种队列，所以我们称其为用户队列) 是用函数 dispatch_queue_create 创建的队列. 这些队列是串行的。正因为如此，它们可以用来完成同步机制, 有点像传统线程中的mutex。

创建队列

要使用用户队列，我们首先得创建一个。调用函数dispatch_queue_create就行了。函数的第一个参数是一个标签，这纯是为了debug。Apple建议我们使用倒置域名来命名队列，比如“com.dreamingwish.subsystem.task”。这些名字会在崩溃日志中被显示出来，也可以被调试器调用，这在调试中会很有用。第二个参数目前还不支持，传入NULL就行了。

提交 Job

向一个队列提交Job很简单：调用dispatch_async函数，传入一个队列和一个block。队列会在轮到这个block执行时执行这个block的代码。下面的例子是一个在后台执行一个巨长的任务：

  1. dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
  2.         [self goDoSomethingLongAndInvolved]; 
  3.         NSLog(@"Done doing something long and involved"); 
  4. }); 

dispatch_async 函数会立即返回, block会在后台异步执行。 

当然，通常，任务完成时简单地NSLog个消息不是个事儿。在典型的Cocoa程序中，你很有可能希望在任务完成时更新界面，这就意味着需要在主线程中执行一些代码。你可以简单地完成这个任务——使用嵌套的dispatch，在外层中执行后台任务，在内层中将任务dispatch到main queue：

  1. dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
  2.         [self goDoSomethingLongAndInvolved]; 
  3.         dispatch_async(dispatch_get_main_queue(), ^{ 
  4.             [textField setStringValue:@"Done doing something long and involved"]; 
  5.         }); 
  6. }); 

还有一个函数叫dispatch_sync，它干的事儿和dispatch_async相同，但是它会等待block中的代码执行完成并返回。结合 __block类型修饰符，可以用来从执行中的block获取一个值。例如，你可能有一段代码在后台执行，而它需要从界面控制层获取一个值。那么你可以使用dispatch_sync简单办到：

  1. __block NSString *stringValue; 
  2. dispatch_sync(dispatch_get_main_queue(), ^{ 
  3.         // __block variables aren't automatically retained 
  4.         // so we'd better make sure we have a reference we can keep 
  5.         stringValue = [[textField stringValue] copy]; 
  6. }); 
  7. [stringValue autorelease]; 
  8. // use stringValue in the background now 

我们还可以使用更好的方法来完成这件事——使用更“异步”的风格。不同于取界面层的值时要阻塞后台线程，你可以使用嵌套的block来中止后台线程，然后从主线程中获取值，然后再将后期处理提交至后台线程：

  1. dispatch_queue_t bgQueue = myQueue; 
  2.    dispatch_async(dispatch_get_main_queue(), ^{ 
  3.        NSString *stringValue = [[[textField stringValue] copy] autorelease]; 
  4.        dispatch_async(bgQueue, ^{ 
  5.            // use stringValue in the background now 
  6.        }); 
  7.    }); 

取决于你的需求，myQueue可以是用户队列也可以使全局队列。

不再使用锁（Lock）

用户队列可以用于替代锁来完成同步机制。在传统多线程编程中，你可能有一个对象要被多个线程使用，你需要一个锁来保护这个对象：

  1. NSLock *lock; 

访问代码会像这样：

  1. - (id)something 
  2.    { 
  3.        id localSomething; 
  4.        [lock lock]; 
  5.        localSomething = [[something retain] autorelease]; 
  6.        [lock unlock]; 
  7.        return localSomething; 
  8.    } 
  9.  
  10.    - (void)setSomething:(id)newSomething 
  11.    { 
  12.        [lock lock]; 
  13.        if(newSomething != something) 
  14.        { 
  15.            [something release]; 
  16.            something = [newSomething retain]; 
  17.            [self updateSomethingCaches]; 
  18.        } 
  19.        [lock unlock]; 
  20.    } 

使用GCD，可以使用queue来替代：

  1. dispatch_queue_t queue; 

要用于同步机制，queue必须是一个用户队列，而非全局队列，所以使用usingdispatch_queue_create初始化一个。然后可以用dispatch_async 或者 dispatch_sync将共享数据的访问代码封装起来：

  1. - (id)something 
  2. { 
  3.     __block id localSomething; 
  4.     dispatch_sync(queue, ^{ 
  5.         localSomething = [something retain]; 
  6.     }); 
  7.     return [localSomething autorelease]; 
  8. } 
  9.  
  10. - (void)setSomething:(id)newSomething 
  11. { 
  12.     dispatch_async(queue, ^{ 
  13.         if(newSomething != something) 
  14.         { 
  15.             [something release]; 
  16.             something = [newSomething retain]; 
  17.             [self updateSomethingCaches]; 
  18.         } 
  19.     }); 
  20. } 

值得注意的是dispatch queue是非常轻量级的，所以你可以大用特用，就像你以前使用lock一样。

现在你可能要问：“这样很好，但是有意思吗？我就是换了点代码办到了同一件事儿。”

实际上，使用GCD途径有几个好处：

  1. 平行计算: 注意在第二个版本的代码中， -setSomething:是怎么使用dispatch_async的。调用 -setSomething:会立即返回，然后这一大堆工作会在后台执行。如果updateSomethingCaches是一个很费时费力的任务，且调用者将要进行一项处理器高负荷任务，那么这样做会很棒。
  2. 安全: 使用GCD，我们就不可能意外写出具有不成对Lock的代码。在常规Lock代码中，我们很可能在解锁之前让代码返回了。使用GCD，队列通常持续运行，你必将归还控制权。
  3. 控制: 使用GCD我们可以挂起和恢复dispatch queue，而这是基于锁的方法所不能实现的。我们还可以将一个用户队列指向另一个dspatch queue，使得这个用户队列继承那个dispatch queue的属性。使用这种方法，队列的优先级可以被调整——通过将该队列指向一个不同的全局队列，若有必要的话，这个队列甚至可以被用来在主线程上执行代码。
  4. 集成: GCD的事件系统与dispatch queue相集成。对象需要使用的任何事件或者计时器都可以从该对象的队列中指向，使得这些句柄可以自动在该队列上执行，从而使得句柄可以与对象自动同步。

Dispatch Queue挂起

dispatch queue可以被挂起和恢复。使用 dispatch_suspend函数来挂起，使用  dispatch_resume 函数来恢复。这两个函数的行为是如你所愿的。另外，这两个函数也可以用于dispatch source。

一个要注意的地方是，dispatch queue的挂起是block粒度的。换句话说，挂起一个queue并不会将当前正在执行的block挂起。它会允许当前执行的block执行完毕，然后后续的block不再会被执行，直至queue被恢复。

还有一个注意点：从man页上得来的：如果你挂起了一个queue或者source，那么销毁它之前，必须先对其进行恢复。

Dispatch Queue目标指定

所有的用户队列都有一个目标队列概念。从本质上讲，一个用户队列实际上是不执行任何任务的，但是它会将任务传递给它的目标队列来执行。通常，目标队列是默认优先级的全局队列。

用户队列的目标队列可以用函数 dispatch_set_target_queue来修改。我们可以将任意dispatch queue传递给这个函数，甚至可以是另一个用户队列，只要别构成循环就行。这个函数可以用来设定用户队列的优先级。比如我们可以将用户队列的目标队列设定为低优先级的全局队列，那么我们的用户队列中的任务都会以低优先级执行。高优先级也是一样道理。

有一个用途，是将用户队列的目标定为main queue。这会导致所有提交到该用户队列的block在主线程中执行。这样做来替代直接在主线程中执行代码的好处在于，我们的用户队列可以单独地被挂起和恢复，还可以被重定目标至一个全局队列，然后所有的block会变成在全局队列上执行（只要你确保你的代码离开主线程不会有问题）。

还有一个用途，是将一个用户队列的目标队列指定为另一个用户队列。这样做可以强制多个队列相互协调地串行执行，这样足以构建一组队列，通过挂起和暂停那个目标队列，我们可以挂起和暂停整个组。想象这样一个程序：它扫描一组目录并且加载目录中的内容。为了避免磁盘竞争，我们要确定在同一个物理磁盘上同时只有一个文件加载任务在执行。而希望可以同时从不同的物理磁盘上读取多个文件。要实现这个，我们要做的就是创建一个dispatch queue结构，该结构为磁盘结构的镜像。

首先，我们会扫描系统并找到各个磁盘，为每个磁盘创建一个用户队列。然后扫描文件系统，并为每个文件系统创建一个用户队列，将这些用户队列的目标队列指向合适的磁盘用户队列。最后，每个目录扫描器有自己的队列，其目标队列指向目录所在的文件系统的队列。目录扫描器枚举自己的目录并为每个文件向自己的队列提交一个block。由于整个系统的建立方式，就使得每个物理磁盘被串行访问，而多个物理磁盘被并行访问。除了队列初始化过程，我们根本不需要手动干预什么东西。

信号量

dispatch的信号量是像其他的信号量一样的，如果你熟悉其他多线程系统中的信号量，那么这一节的东西再好理解不过了。

信号量是一个整形值并且具有一个初始计数值，并且支持两个操作：信号通知和等待。当一个信号量被信号通知，其计数会被增加。当一个线程在一个信号量上等待时，线程会被阻塞（如果有必要的话），直至计数器大于零，然后线程会减少这个计数。

我们使用函数  dispatch_semaphore_create 来创建dispatch信号量，使用函数  dispatch_semaphore_signal 来信号通知，使用函数  dispatch_semaphore_wait 来等待。这些函数的man页有两个很好的例子，展示了怎样使用信号量来同步任务和有限资源访问控制。

单次初始化

GCD还提供单词初始化支持，这个与pthread中的函数  pthread_once 很相似。GCD提供的方式的优点在于它使用block而非函数指针，这就允许更自然的代码方式：

这个特性的主要用途是惰性单例初始化或者其他的线程安全数据共享。典型的单例初始化技术看起来像这样（线程安全的）：

  1. + (id)sharedWhatever 
  2. { 
  3.     static Whatever *whatever = nil; 
  4.     @synchronized([Whatever class]) 
  5.     { 
  6.         if(!whatever) 
  7.             whatever = [[Whatever alloc] init]; 
  8.     } 
  9.     return whatever; 
  10. } 

这挺好的，但是代价比较昂贵；每次调用  +sharedWhatever 函数都会付出取锁的代价，即使这个锁只需要进行一次。确实有更风骚的方式来实现这个，使用类似双向锁或者是原子操作的东西，但是这样挺难弄而且容易出错。

使用GCD，我们可以这样重写上面的方法，使用函数 dispatch_once：

  1. + (id)sharedWhatever 
  2. { 
  3.     static dispatch_once_t pred; 
  4.     static Whatever *whatever = nil; 
  5.     dispatch_once(&pred, ^{ 
  6.         whatever = [[Whatever alloc] init]; 
  7.     }); 
  8.     return whatever; 
  9. } 

这个稍微比 @synchronized方法简单些，并且GCD确保以更快的方式完成这些检测，它保证block中的代码在任何线程通过  dispatch_once 调用之前被执行，但它不会强制每次调用这个函数都让代码进行同步控制。实际上，如果你去看这个函数所在的头文件，你会发现目前它的实现其实是一个宏，进行了内联的初始化测试，这意味着通常情况下，你不用付出函数调用的负载代价，并且会有更少的同步控制负载。

结论

这一章，我们介绍了dispatch queue的挂起、恢复和目标重定，以及这些功能的一些用途。另外，我们还介绍了如何使用dispatch 信号量和单次初始化功能。到此，我已经完成了GCD如何运作以及如何使用的介绍。



1 0
查找算法效率 查找算法效率
原创粉丝点击
热门IT博客
可以用网络爬虫干什么可以用网络爬虫干什么
大宝防晒霜如何 知乎大宝防晒霜如何 知乎
app软件开发课程
nginx 修改默认页面
淘宝个人资料在哪里
java公司官网模板源码
淘宝美工可以自学吗
淘宝联盟还要人脸认证
建筑工程造价软件
多益网络c 面试
复杂网络基础理论
学服装设计用什么软件
java中split的用法
mac口红香港专柜地址
mpi编程double
网络接口分线器一分二
淘宝上冷门的好东西
my sql count 限制条件
js如何给input赋值
时时彩后三缩水软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 糖粉 糖粉是什么 糖粉可以用什么代替 自制糖粉 糖粉怎么做 糖粉能用白糖代替吗 防潮糖粉 无糖豆浆粉 麦芽糖粉 绵白糖和糖粉 什么是糖粉 没有糖粉用什么代替 糖粉和细砂糖的区别 绵白糖是糖粉吗 糖粉的价格 糖粉和白砂糖的区别 糖粉制作 糖粉山楂 糖粉和绵白糖的区别 白砂糖粉 糖粉是什么东西 糖精 糖精是什么 糖精钠 糖精的危害 什么是糖精 糖精钠价格 糖精能吃吗 糖精图片 糖精是糖吗 工业糖精 糖精枣 鸡蛋和糖精 糖精怎么做 鸡蛋加糖精 糖精和鸡蛋能一起吃吗 糖精钠对人体有害吗 有妻足焉 糖精怪 糖精 家有中二 糖精多少钱一斤 糖精哪里可以买到

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里