1 GCD的概念

Grand Central Dispatch(GCD) 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出,也可在 iOS 4 及以上版本使用。

2 GCD的两个核心

GCD的两个核心是任务和队列

2.1 任务

任务就是执行操作的意思,就是线程中需要执行的代码,任务的执行方式有两种方式:同步执行异步执行,二者主要区别是: 是否等待队列的任务执行结束,以及是否具备开启新线程的能力.
同步执行

  • 同步添加任务到指定的队列中,在添加的任务执行结束之前,会一直等待,直到队列里面的任务完成之后再继续执行。
  • 只能在当前线程中执行任务,不具备开启新线程的能力

异步执行

  • 异步添加任务到指定的队列中,它不会做任何等待,可以继续执行任务。
  • 可以在新的线程中执行任务,具备开启新线程的能力

    2.1 队列

    这里的队列指执行任务的等待队列,即用来存放任务的队列。队列是一种特殊的线性表,采用 FIFO(先进先出)的原则,即新任务总是被插入到队列的末尾,而读取任务的时候总是从队列的头部开始读取。每读取一个任务,则从队列中释放一个任务.在GCD中有两种队列: 串行队列并发队列
    串行队列
  1. 每次只有一个任务被执行。让任务一个接着一个地执行。(只开启一个线程,一个任务执行完毕后,再执行下一个任务)

并发队列

  1. 可以让多个任务并发(同时)执行。(可以开启多个线程,并且同时执行任务)

3 GCD的使用

可以使用 dispatch_queue_create 方法来创建队列。该方法需要传入两个参数:

  1. 第一个参数表示队列的唯一标识符,用于 DEBUG,可为空。队列的名称推荐使用应用程序 ID 这种逆序全程域名。
  2. 第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列, DISPATCH_QUEUE_CONCURRENT表示并发队列。

    1. dispatch_queue_t queue = dispatch_queue_create(0, DISPATCH_QUEUE_CONCURRENT);
    2. dispatch_queue_t queue = dispatch_queue_create(0, DISPATCH_QUEUE_SERIAL);

    串行队列还有一个页数的队列叫做主队列.

  3. 主队列中的任务都放到主线程中执行

  4. 可使用 dispatch_get_main_queue``() 方法获得主队列

并发队列系统提供了一个叫做全局并发队列

  1. 可以使用 dispatch_get_global_queue 方法来获取全局并发队列。需要传入两个参数。第一个参数表示队列优先级,一般用 DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用,用 0 即可。

那么GCD的所有组合有:

区别 『异步执行+并发队列』嵌套『同一个并发队列』 『同步执行+并发队列』嵌套『同一个并发队列』 『异步执行+串行队列』嵌套『同一个串行队列』 『同步执行+串行队列』嵌套『同一个串行队列』
同步(sync) 没有开启新的线程,串行执行任务 没有开启新线程,串行执行任务 死锁卡住不执行 死锁卡住不执行
异步(async) 有开启新线程,并发执行任务 有开启新线程,并发执行任务 有开启新线程(1 条),串行执行任务 有开启新线程(1 条),串行执行任务

3 GCD的其他用法

3.1 栅栏方法 dispatch_barrier_async

我们有时需要异步执行两组操作,而且第一组操作执行完之后,才能开始执行第二组操作。这样我们就需要一个相当于 栅栏 一样的一个方法将两组异步执行的操作组给分割起来,当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async 方法在两个操作组间形成栅栏。

  1. - (void)barrier {
  2. dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
  3. dispatch_async(queue, ^{
  4. // 追加任务 1
  5. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
  6. NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
  7. });
  8. dispatch_async(queue, ^{
  9. // 追加任务 2
  10. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
  11. NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
  12. });
  13. dispatch_barrier_async(queue, ^{
  14. // 追加任务 barrier
  15. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
  16. NSLog(@"barrier---%@",[NSThread currentThread]);// 打印当前线程
  17. });
  18. dispatch_async(queue, ^{
  19. // 追加任务 3
  20. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
  21. NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
  22. });
  23. dispatch_async(queue, ^{
  24. // 追加任务 4
  25. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
  26. NSLog(@"4---%@",[NSThread currentThread]); // 打印当前线程
  27. });
  28. }

最后先打印任务1 2,然后才打印任务3,4.

3.2 GCD延时执行方法 dispatch_after

在指定时间之后执行某个任务。可以用 GCD 的dispatch_after 方法来实现。dispatch_after 方法并不是在指定时间之后才开始执行处理,而是在指定时间之后将任务追加到主队列中。严格来说,这个时间并不是绝对准确的,但想要大致延迟执行任务,dispatch_after 方法是很有效的。

  1. /**
  2. * 延时执行方法 dispatch_after
  3. */
  4. - (void)after {
  5. NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
  6. NSLog(@"asyncMain---begin");
  7. dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
  8. // 2.0 秒后异步追加任务代码到主队列,并开始执行
  9. NSLog(@"after---%@",[NSThread currentThread]); // 打印当前线程
  10. });
  11. }

在打印 asyncMain—-begin之后大约 2.0 秒的时间,打印了after—-{number = 1,name = main}.

3.3 GCD 一次性代码 dispatch_once

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时,我们就用到了 GCD 的 dispatch_once 方法。使用 dispatch_once 方法能保证某段代码在程序运行过程中只被执行 1 次,并且即使在多线程的环境下,dispatch_once 也可以保证线程安全。

  1. /**
  2. * 一次性代码(只执行一次)dispatch_once
  3. */
  4. - (void)once {
  5. static dispatch_once_t onceToken;
  6. dispatch_once(&onceToken, ^{
  7. // 只执行 1 次的代码(这里面默认是线程安全的)
  8. });
  9. }

3.4 GCD 队列组 dispatch_group

分别异步执行2个耗时任务,然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。

  1. /**
  2. * 队列组 dispatch_group_notify
  3. */
  4. - (void)groupNotify {
  5. NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
  6. NSLog(@"group---begin");
  7. dispatch_group_t group = dispatch_group_create();
  8. dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  9. // 追加任务 1
  10. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
  11. NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
  12. });
  13. dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  14. // 追加任务 2
  15. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
  16. NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
  17. });
  18. dispatch_group_notify(group, dispatch_get_main_queue(), ^{
  19. // 等前面的异步任务 1、任务 2 都执行完毕后,回到主线程执行下边任务
  20. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
  21. NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
  22. NSLog(@"group---end");
  23. });
  24. }

3.5 dispatch_group_wait

暂停当前线程(阻塞当前线程),等待指定的 group 中的任务执行完成后,才会往下继续执行。

  1. /**
  2. * 队列组 dispatch_group_wait
  3. */
  4. - (void)groupWait {
  5. NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
  6. NSLog(@"group---begin");
  7. dispatch_group_t group = dispatch_group_create();
  8. dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  9. // 追加任务 1
  10. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
  11. NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
  12. });
  13. dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  14. // 追加任务 2
  15. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
  16. NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
  17. });
  18. // 等待上面的任务全部完成后,会往下继续执行(会阻塞当前线程)
  19. dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
  20. NSLog(@"group---end");
  21. }

3.6 dispatch_group_enter、dispatch_group_leave

  1. dispatch_group_enter 标志着一个任务追加到 group,执行一次,相当于 group 中未执行完毕任务数 +1
  2. dispatch_group_leave 标志着一个任务离开了 group,执行一次,相当于 group 中未执行完毕任务数 -1。
  3. 当 group 中未执行完毕任务数为0的时候,才会使 dispatch_group_wait 解除阻塞,以及执行追加到 dispatch_group_notify 中的任务。 ```dart /**
    • 队列组 dispatch_group_enter、dispatch_group_leave */
  • (void)groupEnterAndLeave { NSLog(@”currentThread—-%@”,[NSThread currentThread]); // 打印当前线程 NSLog(@”group—-begin”);

    dispatch_group_t group = dispatch_group_create(); dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_group_enter(group); dispatch_async(queue, ^{

    1. // 追加任务 1
    2. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
    3. NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
    4. dispatch_group_leave(group);

    });

    dispatch_group_enter(group); dispatch_async(queue, ^{

    1. // 追加任务 2
    2. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
    3. NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
    4. dispatch_group_leave(group);

    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{

    1. // 等前面的异步操作都执行完毕后,回到主线程.
    2. [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
    3. NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
    4. NSLog(@"group---end");

    }); } ```

    3.7 GCD信号量 dispatch_semaphore

    GCD 中的信号量是指 Dispatch Semaphore,是持有计数的信号。类似于过高速路收费站的栏杆。可以通过时,打开栏杆,不可以通过时,关闭栏杆。在 Dispatch Semaphore 中,使用计数来完成这个功能,计数小于 0 时等待,不可通过。计数为 0 或大于 0 时,计数减 1 且不等待,可通过。
    Dispatch Semaphore 提供了三个方法:

  1. dispatch_semaphore_create:创建一个 Semaphore 并初始化信号的总量
  2. dispatch_semaphore_signal:发送一个信号,让信号总量加 1
  3. dispatch_semaphore_wait:可以使总信号量减 1,信号总量小于 0 时就会一直等待(阻塞所在线程),否则就可以正常执行。