iOS - GCD的简单的用法

在学习简单使用GCD API 之前我们先简单了解一下基本概念。

文章目录

在学习简单使用GCD API 之前我们先简单了解一下基本概念。

同步和异步
并行|并发和串行
队列
串行队列
并行队列
官方文档
GCD的使用
队列的创建方法|获取方法
任务的创建方法
GCD之间的通信
GCD 的其他方法

GCD 栅栏方法 dispatch_barrier_async
GCD 延时执行方法：dispatch_after
GCD 一次性代码（只执行一次）：dispatch_once
GCD 快速迭代方法：dispatch_apply
GCD 队列组：dispatch_group
dispatch_group_notify

同步和异步

同步执行(sync)：

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

异步执行(async)：

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

注意：异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关（下面会讲）。

并行|并发和串行

并行：指多个任务在同一时刻发生。多核CPU同时开启多条线程供多个任务同时执行，互不干扰。
并发：指多个任务在同一时间间隔内发生。通俗来说就是几个任务在一个线程中交替进行。
串行：指多个任务在一个线程中一个接一个的执行。

队列

在这里插入图片描述

队列是用来存放任务的，一共有两种队列：串行队列和并行队列（两者的主要区别是：执行顺序不同，以及开启线程数不同。）

串行队列
- 每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）
- 放在串行队列的任务，GCD 会 FIFO（先进先出）地取出来一个，执行一个，然后取下一个，这样一个一个的执行
并行队列
- 并发队列（Concurrent Dispatch Queue）：
  可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）注意：并发队列的并发功能只有在异步（dispatch_async）函数下才有效

官方文档

开发者要做的只是定义想执行的任务并追加到适当的Dispatch Queue中。Dispatch Queue是执行处理的等待队列。我们可以通过dispatch-async等API，在block语法中记述想要执行的处理并将其追加到Dispatch Queue中，Dispatch Queue是按照追加的顺序进行处理，先进先出（FIFO）。
在执行处理的时候有两种Dispatch Queue，一种是Serial Dispatch Queue串行调度队列，这个是等待现在执行中的事件处理结束。另一种是Concurrent Dispatch Queue并发调度队列，这个是不等待现在执行中的事件处理结束。

GCD的使用

GCD 的使用步骤其实很简单，只有两步。

1 创建一个队列（串行队列或并发队列）
2 将任务追加到任务的等待队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）
下边来看看队列的创建方法/获取方法，以及任务的创建方法。

队列的创建方法|获取方法

可以使用dispatch_queue_create来创建队列，需要传入两个参数，第一个参数表示队列的唯一标识符，用于 DEBUG，可为空，Dispatch Queue 的名称推荐使用应用程序 ID 这种逆序全程域名；第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列，DISPATCH_QUEUE_CONCURRENT 表示并发队列。
- 1). dispatch_queue_create函数生成Dispatch Queue
```
 // 同步执行任务创建方法
  dispatch_sync(dispatch_queue_t  _Nonnull queue, ^{
 // 执行的代码
 });
 //异步执行任务的创建方法
 	 dispatch_async(dispatch_queue_t  _Nonnull queue, ^{
 // 执行的代码
 });
```
- 2).使用系统提供的Dispatch Queue。
  - 对于串行队列，GCD 提供了的一种特殊的串行队列：主队列（Main Dispatch Queue）。
    所有放在主队列中的任务，都会放到主线程中执行。
    可使用dispatch_get_main_queue()获得主队列。
```
  //主队列的获取方法
     dispatch_queue_t queue = dispatch_get_main_queue();
```
  - 对于并发队列，GCD 默认提供了全局并发队列（Global Dispatch Queue）。
    可以使用dispatch_get_global_queue来获取。需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。
```
  该方法的第一个参数是执行的优先级，系统提供了
  DISPATCH_QUEUE_PRIORITY_DEFAULT. (默认优先级)
  DISPATCH_QUEUE_PRIORITY_BACKGROUND。（后台优先级）
  DISPATCH_QUEUE_PRIORITY_HIGH。 （高优先级）
  DISPATCH_QUEUE_PRIORITY_LOW。 （低优先级）
```
    四个参数供选择，其中后台优先级表示用户不需要知道任务什么时候完成，如果选择这个选项速度会特别慢，不利于调试，不建议多使用。第二个参数是个标记，是为了未来使用保留的，建议这个参数设置为0。只要是并行任务一般都加入到这个队列。这是系统提供的一个全局并发队列。

任务的创建方法

GCD 提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async。

同步任务(dispatch_sync)
不会另开线程，会阻塞当前线程 (SYNC)。
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
```
  // 同步执行任务创建方法
  dispatch_sync(queue, ^{
  // 这里放同步执行任务代码
  });
```

+异步任务(dispatch_async)
会另开线程,不会阻塞当前线程 (ASYNC)。
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

	// 异步执行任务创建方法
	dispatch_async(queue, ^{
    // 这里放异步执行任务代码
	});

GCD之间的通信

在iOS开发过程中，我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

- (void)communication {
    // 获取全局并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 获取主队列
    //dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        // 异步追加任务
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
        // 回到主线程
        dispatch_async(mainQueue, ^{
            // 追加在主线程中执行的任务
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        });
         NSLog(@"1234");
    });
    NSLog(@"123");
}

输出结果如下在这里插入图片描述
这里回到主线程这里用的是async 就其实在想用sync是否可以就其实有点想看你这里的需求，如果你想要的是回到主线程后在进行1234的打印然后就可以用sync而如果没有就一般用sync。

GCD 的其他方法

GCD 栅栏方法 dispatch_barrier_async

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。
dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。具体如下图所示：
/**

栅栏方法 dispatch_barrier_async
*/

 - (void)barrier {
 dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
 
 dispatch_async(queue, ^{
     // 追加任务1
     for (int i = 0; i < 2; ++i) {
         [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
         NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
     }
 });
 dispatch_async(queue, ^{
     // 追加任务2
     for (int i = 0; i < 2; ++i) {
         [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
         NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
     }
 });
 
 dispatch_barrier_async(queue, ^{
     // 追加任务 barrier
     for (int i = 0; i < 2; ++i) {
         [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
         NSLog(@"barrier---%@",[NSThread currentThread]);// 打印当前线程
     }
 });
 
 dispatch_async(queue, ^{
     // 追加任务3
     for (int i = 0; i < 2; ++i) {
         [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
         NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
     }
 });
 dispatch_async(queue, ^{
     // 追加任务4
     for (int i = 0; i < 2; ++i) {
         [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
         NSLog(@"4---%@",[NSThread currentThread]);      // 打印当前线程
     }
 });

打印如下在这里插入图片描述

GCD 延时执行方法：dispatch_after

我们经常会遇到这样的需求：在指定时间（例如3秒）之后执行某个任务。可以用 GCD 的dispatch_after函数来实现。
需要注意的是：dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。
- (void)after {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"asyncMain---begin");
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2.0秒后异步追加任务代码到主队列，并开始执行
        NSLog(@"after---%@",[NSThread currentThread]);  // 打印当前线程
    });
}

在这里插入图片描述

GCD 一次性代码（只执行一次）：dispatch_once

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

/**
 * 一次性代码（只执行一次）dispatch_once
 */
- (void)once {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只执行1次的代码(这里面默认是线程安全的)
    });
}

如下
在这里插入图片描述

GCD 快速迭代方法：dispatch_apply

通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的函数dispatch_apply。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。
如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。可这样就体现不出快速迭代的意义了。
我们可以利用并发队列进行异步执行。比如说遍历 0~5 这6个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply 可以在多个线程中同时（异步）遍历多个数字。
还有一点，无论是在串行队列，还是异步队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。
```
  - (void)apply {
  dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  
  NSLog(@"apply---begin");
  dispatch_apply(10, queue, ^(size_t index) {
      NSLog(@"%zd---%@",index, [NSThread currentThread]);
  });
  NSLog(@"apply---end");
```
}

GCD 队列组：dispatch_group

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

调用队列组的 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中。或者使用队列组的 dispatch_group_enter、dispatch_group_leave 组合来实现
dispatch_group_async。

dispatch_group_wait. 暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。

  - (void)groupWait {
      NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
      NSLog(@"group---begin");
      dispatch_group_t group =  dispatch_group_create();
  
  dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
      // 追加任务1
      for (int i = 0; i < 2; ++i) {
          [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
          NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
      }
  });
  
  dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
      // 追加任务2
      for (int i = 0; i < 2; ++i) {
          [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
          NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
      }
  });

dispatch_group_enter、dispatch_group_leavedispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1
dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。
当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。

调用队列组的 dispatch_group_notify 回到指定线程执行任务。或者使用 dispatch_group_wait 回到当前线程继续向下执行（会阻塞当前线程）。

dispatch_group_notify

监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务。

  	/**
   * 队列组 dispatch_group_notify
   */
  - (void)groupNotify {
      NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
      NSLog(@"group---begin");
      
      dispatch_group_t group =  dispatch_group_create();
      
      dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
          // 追加任务1
          for (int i = 0; i < 2; ++i) {
              [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
              NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
          }
      });
      
      dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
          // 追加任务2
          for (int i = 0; i < 2; ++i) {
              [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
              NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
          }
      });
      
      dispatch_group_notify(group, dispatch_get_main_queue(), ^{
          // 等前面的异步任务1、任务2都执行完毕后，回到主线程执行下边任务
          for (int i = 0; i < 2; ++i) {
              [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
              NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
          }
          NSLog(@"group---end");
      });
  }

本文参考文章

向景乐

发布了34 篇原创文章 · 获赞 4 · 访问量 719

私信关注