iOS开发之 GCD 使用

时间:2016年8月30日 15:22 点击:684次
1. GCD 全称是Grand Central Dispatch,可译为“大中央中枢调度器”
 (1)GCD存在于
libdispatch.dylib(或者libdispatch.tbd)这个库中,这个调度库包含了GCD的所有的东西,但任何IOS程序,默认就加
载了这个库,在程序运行的过程中会动态的加载这个库,不需要我们手动导入。 
(2)GCD是纯C语言的,因此我们在编写GCD相关代码的时候,面对的函数,而不是方法。
(3)GCD中的函数大多数都以dispatch开头。

2. GCD的优势
   GCD是苹果公司为多核的并行运算提出的解决方案
   GCD会自动利用更多的CPU内核(比如双核、四核)
   GCD会自动管理线程的生命周期(创建线程、调度任务、销毁线程)
   程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码
3. GCD队列的概念
有4个术语比较容易混淆:同步、异步、并发、串行
同步和异步决定了要不要开启新的线程
同步:在当前线程中执行任务,不具备开启新线程的能力
异步:在新的线程中执行任务,具备开启新线程的能力
并发和串行决定了任务的执行方式
并发:多个任务并发(同时)执行
串行:一个任务执行完毕后,再执行下一个任务
在多线程开发当中,程序员只要将想做的事情定义好,并追加到DispatchQueue(派发队列)当中就好了。
派发队列分为两种,一种是串行队列(SerialDispatchQueue),一种是并行队列(ConcurrentDispatchQueue)。
一个任务就是一个block,比如,将任务添加到队列中的代码是:
1 dispatch_async(queue, block);
当给queue添加多个任务时,如果queue是串行队列,则它们按顺序一个个执行,同时处理的任务只有一个。
当queue是并行队列时,不论第一个任务是否结束,都会立刻开始执行后面的任务,也就是可以同时执行多个任务。
但是并行执行的任务数量取决于设备内核数量,是不可控的。比如,如果同时执行10个任务,那么10个任务并不是开启10个线程,线程会根据任务执行情况复用,由系统控制。
获取队列
系统提供了两个队列,一个是MainDispatchQueue(主队列),一个是GlobalDispatchQueue(全局队列)。
主队列 会将任务插入主线程的RunLoop当中去执行,所以显然是个串行队列,我们可以使用它来更新UI。
全局队列 则是一个全局的并行队列,有高、默认、低和后台4个优先级。
它们的获取方式如下:
获取主串行队列: dispatch_queue_t queue = dispatch_get_main_queue();

获取全局并行队列:  dispatch queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRORITY_DEFAULT, 0)
执行异步任务
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
   dispatch_async(queue, ^{
       //...要执行的任务
    });
这个代码片段直接在子线程里执行了一个任务块。使用GCD方式任务是立即开始执行的
它不像操作队列那样可以手动启动,同样,缺点也是它的不可控性。
令任务只执行一次
+ (id)shareInstance {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _shareInstance = [[self alloc] init];
   });
}
这种只执行一次且线程安全的方式经常出现在单例构造器当中。
任务组
有时候,我们希望多个任务同时(在多个线程里)执行,再他们都完成之后,再执行其他的任务,
于是可以建立一个分组,让多个任务形成一个组,下面的代码在组中多个任务都执行完毕之后再执行后续的任务:
dispatch_queue_t  queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
   dispatch_group_t  group = dispatch_group_create();

   dispatch_group_async(group, queue, ^{ NSLog(@"1"); });
    dispatch_group_async(group, queue, ^{ NSLog(@"2"); });
    dispatch_group_async(group, queue, ^{ NSLog(@"3"); });
    dispatch_group_async(group, queue, ^{ NSLog(@"4"); });
    dispatch_group_async(group, queue, ^{ NSLog(@"5"); });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{ 
       NSLog(@"done"); 
});


延迟执行任务
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
       //...
    });
这段代码将会在10秒后将任务插入RunLoop当中。
dispatch_asycn和dispatch_sync
先前已经有过一个使用dispatch_async执行异步任务的一个例子,下面来看一段异步执行的代码:

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  dispatch_async(queue, ^{
        NSLog(@"1");
    });
    NSLog(@"2");
这段代码首先获取了全局队列,也就是
说,dispatch_async当中的任务被丢到了另一个线程里去执行,async在这里的含义是,当 当前线程给子线程分配了block当中的任务之
后,当前线程会立即执行,并不会发生阻塞,也就是异步的。那么,输出结果不是1 2就是2 1,因为我们没法把控两个线程RunLoop里到底是怎么执行的。
类似的,还有一个“同步”方法dispatch_sync,代码如下:
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_sync(queue, ^{
        NSLog(@"1");
    });
    NSLog(@"2");
这就意味着,当主线程将任务分给子线程后,主线程会等待子线程执行完毕,再继续执行自身的内容,那么结果显然就是12了。
需要注意的一点是,这里用的是全局队列,那如果把dispatch_sync的队列换成主线程队列会怎么样呢:
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        NSLog(@"1");
    });
这段代码会发生死锁,因为:
1.主线程通过dispatch_sync把block交给主队列后,会等待block里的任务结束再往下走自身的任务,
2.而队列是先进先出的,block里的任务也在等待主队列当中排在它之前的任务都执行完了再走自己。
这种循环等待就形成了死锁。所以在主线程当中使用dispatch_sync将任务加到主队列是不可取的。
创建队列
我们可以使用系统提供的函数获取 主串行队列和 全局 并行队列,当然也可以自己手动创建串行和并行队列,代码为:
自己手动创建串行队列     dispatch_queue_t  mySerialDispatchQueue = dispatch_queue_create("com.Steak.GCD", DISPATCH_QUEUE_SERIAL);
自己手动创建并行队列     dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.Steak.GCD", DISPATCH_QUEUE_CONCURRENT);
在MRC下,手动创建的队列是需要释放的(当然我们现在基本不会用到的)
    dispatch_release(myConcurrentDispatchQueue);
手动创建的队列 和 默认优先级全局队列优先级等同,如果需要修改队列的优先级,需要:
 手动创建的并行队列 
 dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.Steak.GCD", DISPATCH_QUEUE_CONCURRENT);
系统默认的全局队列
   dispatch_queue_t targetQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
使他们的优先级相同     
dispatch_set_target_queue(myConcurrentDispatchQueue, targetQueue);
上面的代码修改队列的优先级为后台级别,即与默认的后台优先级的全局队列等同。
串行、并行队列与读写安全性
在向串行队列(SerialDispatchQueue)当中加入多个block任务后,一次只能同时执行一个block,如果生成了n个串行队列,并且向每个队列当中都添加了任务,那么系统就会启动n个线程来同时执行这些任务。
对于串行队列,正确的使用时机,是在需要解决数据/文件竞争问题时使用它。比如,我们可以令多个任务同时访问一块数据,这样会出现冲突,也可以把每个操作都加入到一个串行队列当中,因为串行队列一次只能执行一个线程的任务,所以不会出现冲突。
但是考虑到串行队列会因为上下文切换而拖慢系统性能,所以我们还是很期望采用并行队列的,来看下面的示例代码:
        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
       dispatch_async(queue, ^{
         //数据读取
     });
      dispatch_async(queue, ^{
         //数据读取2
     });
     dispatch_async(queue, ^{
         //数据写入
     });
     dispatch_async(queue, ^{
         //数据读取3
    });
     dispatch_async(queue, ^{
         //数据读取4
     });
显然,这5个操作的执行顺序是我们无法预期的,我们希望在读取1和读取2执行结束后,再执行写入,写入完成后再执行读取3和读取4。
为了实现这个效果,这里可以使用GCD的另一个API:
    dispatch_barrier_async(queue, ^{
        //数据写入
    });
这样就保证的写入操作的并发安全性。
对于没有数据竞争的并行操作,则可以使用并行队列(CONCURRENT)来实现。
JOIN行为
CGD利用dispatch_group_wait来实现多个操作的join行为,代码如下:
 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
     dispatch_group_t  group = dispatch_group_create();
     dispatch_group_async(group, queue, ^{
         sleep(0.5);
        NSLog(@"1");
     });
     dispatch_group_async(group, queue, ^{
         sleep(1.5);
         NSLog(@"2");
     });
     dispatch_group_async(group, queue, ^{
         sleep(2.5);
         NSLog(@"3");
     });
     NSLog(@"aaaaa");
     dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 2ull * NSEC_PER_SEC);
     if (dispatch_group_wait(group, time) == 0) {
         NSLog(@"已经全部执行完毕");
    }
     else {
         NSLog(@"没有执行完毕");
     }
     NSLog(@"bbbbb");
这里起了3个异步线程放在一个组里,之后通过dispatch_time_t创建了一个超时时间(2秒),程序之后行,立即输出了aaaaa,这是主
线程输出的,当遇到dispatch_group_wait时,主线程会被挂起,等待2秒,在等待的过程当中,子线程分别输出了1和2,2秒时间达到后,
主线程发现组里的任务并没有全部结束,然后输出了bbbbb。
在这里,如果超时时间设置得比较长(比如5秒),那么会在2.5秒时第三个任务结束后,立即输出bbbbb,也就是说,当组中的任务全部执行完毕时,主线程就不再被阻塞了。
如果希望永久等待下去,时间可以设置为DISPATCH_TIME_FOREVER。
并行循环
OC也可以让循环并行执行,在GCD当中有一个dispatch_apply函数:
1     dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
2     dispatch_apply(20, queue, ^(size_t i) {
3         NSLog(@"%lu", i);
4     });
这段代码让i并行循环了20次,如果内部处理的是一个数组,就可以实现对数组的并行循环了,它的内部是dispatch_sync的同步操作,所以在执行这个循环的过程当中,当前线程会被阻塞。
暂停和恢复
使用dispatch_suspend(queue)可以暂停队列中任务的执行,使用dispatch_result(queue)可以继续执行被暂停的队列。
这里在右侧