码迷，mamicode.com
首页 > 其他好文 > 详细

GCD

时间：2015-04-09 17:24:56      阅读：142      评论：0      收藏：0      [点我收藏+]

标签：

什么是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相集成。对象需要使用的任何事件或者计时器都可以从该对象的队列中指向，使得这些句柄可以自动在该队列上执行，从而使得句柄可以与对象自动同步。

GCD

标签：

原文地址：http://blog.csdn.net/learnios/article/details/44962309
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！