iOS GCD浅谈

1、GCD 全称 Grand Central Dispatch 

2、功能：

一、调度队列：所有的调度队列都是先进先出队列，因此，队列中的任务的开始的顺序和添加到队列中的顺序相同。GCD自动的为我们提供了一些调度队列，我们也可以创建新的用于具体的目的。

二、调度资源：它是一个监视某些类型事件的对象。当这些事件发生时，它自动将一个block放入一个调度队列的执行例程中。

三、调度组：允许将多任务分组来方便后来加入执行。任务能作为一个组中的一个成员被加到队列中，客户端能用这个组对象来等待直到这个组中的所有任务完成。

四、调度信号量 ：允许客户端并行发布一定数量的任务。

3、代码：

1) 、声明一个队列；

如下会返回一个用户创建的队列：

dispatch_queue_t myQueue = dispatch_queue_create("com.iphonedevblog.post", NULL);

其中，第一个参数是标识队列的，第二个参数是用来定义队列的参数（目前不支持，因此传入NULL）。

2）、执行一个队列    

    dispatch_async(myQueue, ^{ [self doSomething]; });

        其中，首先传入之前创建的队列，然后提供由队列运行的代码块。

3）、 声明并执行一个队列；

如果不需要保留要运行的队列的引用，可以通过如下代码实现之前的功能：

dispatch_async(dispatch_queue_create ("com.iphonedevblog.post", NULL), ^{
     [self doSomething]; }
 );

<span style="font-family: arial, 宋体, sans-serif; font-size: 1em; text-indent: 2em; background-color: rgb(255, 255, 255);">如果需要暂停一个队列，可以调用如下代码。暂停一个队列会阻止和该队列相关的所有代码运行。</span>

dispatch_suspend(myQueue);//暂停一个队列
dispatch_resume(myQueue);//恢复一个队列

注意：如果暂停一个队列不要忘记恢复。暂停和恢复的操作和内存管理中的retain和release类似。调用dispatch_suspend会增加暂停计数，而dispatch_resume则会减少。队列只有在暂停计数变成零的情况下才开始运行。

4）、从队列中在主线程中运行运行代码

有些操作无法在异步队列运行，因此必须在主线程（每个应用都有一个）上运行。UI绘图以及任何对NSNotificationCenter的调用必须在主线程长进行。在另一个队列中访问主线程并运行代码的示例如下：

dispatch_sync(dispatch_get_main_queue(), ^{ 
        [self dismissLoginWindow]; }
);
//注意，dispatch_suspend （以及dispatch_resume）在主线程上不起作用。

在这里说明几点以前我不明的，

GCD有3种队列类型：

a、The main queue ：与主线程功能相同。实际上，提交至main queue 的任务会在主线程中执行。main queue 可以调度dispatch_get_main_queue()来获得，因为main queue是与主线程相关的，所以这是一个串行队里。

b、Global queues：  全局队列也就并发队列，并有整个进程共享。进程中存在三个全局队列：高、中（默认）、低三个优先级队列。可以调度dispatch_get_global_queue函数传入优先级来访问队列。

c、用户队列：用户队列（ GCD并不这样称呼这种队列, 但是没有一个特定的名字来形容这种队列，所以我们称其为用户队列）是用函数dispatch_queue_create创建的队列，这些队列是串行的。正因为如此，他们可以用来完成同步机制，有点像传统线程中的mutex。

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

提交job两种方式：

1、dispatch_async 函数会立即返回。Block会在后台异步执行。

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. });

2、还有一个函数叫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来中止后台线程，然后从主线程中获取值，然后再将后期处理提交至后台线程：

  
  
dispatch_queue_t bgQueue = myQueue; 
   dispatch_async(dispatch_get_main_queue(), ^{ 
       NSString *stringValue = [[[textField stringValue] copy] autorelease]; 
       dispatch_async(bgQueue, ^{ 
           // use stringValue in the background now 
       }); 
   }); 

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

不再使用锁（Lock）

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

  
  
NSLock *lock; 

访问代码会像这样：

  
  
- (id)something 
   { 
       id localSomething; 
       [lock lock]; 
       localSomething = [[something retain] autorelease]; 
       [lock unlock]; 
       return localSomething; 
   } 
 
   - (void)setSomething:(id)newSomething 
   { 
       [lock lock]; 
       if(newSomething != something) 
       { 
           [something release]; 
           something = [newSomething retain]; 
           [self updateSomethingCaches]; 
       } 
       [lock unlock]; 
   } 

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

  
  
dispatch_queue_t queue; 

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

  
  
- (id)something 
{ 
    __block id localSomething; 
    dispatch_sync(queue, ^{ 
        localSomething = [something retain]; 
    }); 
    return [localSomething autorelease]; 
} 
 
- (void)setSomething:(id)newSomething 
{ 
    dispatch_async(queue, ^{ 
        if(newSomething != something) 
        { 
            [something release]; 
            something = [newSomething retain]; 
            [self updateSomethingCaches]; 
        } 
    }); 
}