GCD 之队列（Dispatch queue）

GCD（Grand Central Dispatch） 介绍

GCD 属于系统级的线程管理，在 Dispatch queue 中执行任务时性能非常的高。GCD 和 operation queue 一样都是基于队列的并发编程 API，它们通过集中管理大家协同使用的线程池。GCD 这块已经开源（开源地址）。

队列

GCD 中的使用 FIFO 队列，用来保证先进来的任务先得到执行，这种队列称之为 dispatch queue。队列一共有两种类型，分别如下：

• 串行队列（Serial queue）：又叫 private dispatch queues，同时只执行一个任务（单独的 block 块），常用于同步访问特定的资源或数据。当创建多个 serial queue 时，虽然各自是同步，但 serial queue 之间是并发执行的。

• 并行队列（Concurrent queue）：又叫 global dispatch queue，可以并发的执行多个任务（多个 block 块），但执行完成顺序是随机的。

全局队列

系统提供了 5 个不同全局队列，分别为：

• 主队列（main queue）
• 4个不同优先级的后台队列，它们的优先级分别为：High Priority Queue，Default Priority Queue，Low Priority Queue，及优先级更低的 Background Priority Queue（用于 I/O）。

主队列（ main queue ）是主线程中的唯一队列，它是一个串行队列。获取主队列的函数如下：

dispatch_queue_t dispatch_get_main_queue(void)

全局队列都为并行的队列，获取方式如下：

• object-c

  dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);
  

  此函数接收两个参数，第一个参数 identifier 是队列的标识符，第二个参数 flags 标记保留供将来使用，始终对此参数指定0即可。identifier 可以用下面的宏来指定不同优先级的队列。

  #define DISPATCH_QUEUE_PRIORITY_HIGH 2
  #define DISPATCH_QUEUE_PRIORITY_DEFAULT 0
  #define DISPATCH_QUEUE_PRIORITY_LOW (-2)
  #define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN
  

• swift 3.0
  在 swift 中对 GCD 相关 API 进行了封装，全部使用类来操作。swift 可以调用 DispatchQueue 的类方法获取：

// swift 3.0
public class func global(qos: DispatchQoS.QoSClass = default) -> DispatchQueue

这四种队列的优先级分别为：

• QOS_CLASS_USER_INTERACTIVE：user interactive 等级表示任务需要被立即执行，用来在响应事件之后更新 UI，来提供好的用户体验。这个等级最好保持小规模。
• QOS_CLASS_USER_INITIATED：user initiated 等级表示任务由 UI 发起异步执行。适用场景是需要及时结果同时又可以继续交互的时候。
• QOS_CLASS_UTILITY：utility 等级表示需要长时间运行的任务，伴有用户可见进度指示器。经常会用来做计算，I/O，网络，持续的数据填充等任务。这个任务节能。
• QOS_CLASS_BACKGROUND：background 等级表示用户不会察觉的任务，使用它来处理预加载，或者不需要用户交互和对时间不敏感的任务。
  全局队列不是用户创建的，只能被获取，为了方便 GCD 的使用，apple 默认为我们提供的。

自定义队列

创建队列

除了系统提供的全局队列，也可以创建自定义队列。可以创建串行队列和并行队列两种类型的队列。创建自定义队列的方法如下：

• object-c

dispatch_queue_t dispatch_queue_create(const char *_Nullable label,
            dispatch_queue_attr_t _Nullable attr);

此函数接收两个参数。第一个参数 label 为队列的标识符，遵循反向DNS命名习惯，方便描述，第二个参数 attr 为队列的属性。当 attr 为 NULL 或者 DISPATCH_QUEUE_SERIAL 时，可以创建串行队列，为 DISPATCH_QUEUE_CONCURRENT 时可以创建并行队列。
例如：

 // 串行队列
dispatch_queue_create("com.fyf.serialqueue", DISPATCH_QUEUE_SERIAL)
// 并行队列
dispatch_queue_create("com.fyf.concurrentqueue", DISPATCH_QUEUE_CONCURRENT)

• switf
  在 swift 中 dispatch queue 对应的类为 DispatchQueue，可以使用下面方法进行初始化：

init(label: String, qos: DispatchQoS = default, attributes: DispatchQueue.Attributes = default, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency = default, target: DispatchQueue? = default)

设定队列优先级

• object-c
  在 object-c 中有两种方式设置自定义队列的优先级，第一种为在创建队列时，用包含优先级的属性来指定队列的优先级。

dispatch_queue_attr_t dispatch_queue_attr_make_with_qos_class(dispatch_queue_attr_t _Nullable attr,
dispatch_qos_class_t qos_class, int relative_priority);

例如：

dispatch_queue_attr_t attr = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_UTILITY, -1);
dispatch_queue_t queue = dispatch_queue_create("com.fyf.qosqueue", attr);

第二种方法为参考其他队列的优先级，来设置自定义队列的优先级。

void dispatch_set_target_queue(dispatch_object_t object,
      dispatch_queue_t _Nullable queue);

dispatch_set_target_queue 可以将参数 object 的优先级设置为 queue 的优先级。例如：

//需要设置优先级的 queue
dispatch_queue_t queue = dispatch_queue_create("com.fyf.settargetqueue", NULL); 
//参考优先级 queue
dispatch_queue_t referQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0); 
dispatch_set_target_queue(queue, referQueue); //设置 queue 和 referQueue 的优先级一样

dispatch_set_target_queue 也可以设置队列层级体系，比如让多个串行和并行队列在统一一个串行队列里串行执行，如下：

dispatch_queue_t serialQueue = dispatch_queue_create("com.fyf.serialqueue", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t firstQueue = dispatch_queue_create("com.fyf.firstqueue", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t secondQueue = dispatch_queue_create("com.fyf.secondqueue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_set_target_queue(firstQueue, serialQueue);
    dispatch_set_target_queue(secondQueue, serialQueue);
    dispatch_async(serialQueue, ^{
        NSLog(@"serialQueue 线程为：%@", [NSThread currentThread]);
    });
    dispatch_async(firstQueue, ^{
        NSLog(@"开始第 1 个任务。%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:3.f];
        NSLog(@"结束第 1 个任务。");
    });
    dispatch_async(secondQueue, ^{
        NSLog(@"开始第 2 个任务。%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"结束第 2 个任务。");
    });
    dispatch_async(secondQueue, ^{
        NSLog(@"开始第 3 个任务。%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:1.f];
        NSLog(@"结束第 3 个任务。");
    });

输出：

serialQueue 线程为：< NSThread: 0x608000079040>{number = 3, name = (null)}
开始第 1 个任务。< NSThread: 0x608000079040>{number = 3, name = (null)}
结束第 1 个任务。
开始第 2 个任务。< NSThread: 0x608000079040>{number = 3, name = (null)}
结束第 2 个任务。
开始第 3 个任务。< NSThread: 0x608000079040>{number = 3, name = (null)}
结束第 3 个任务。

由此可见，添加到 firstQueue 和 secondQueue 中的任务都在 serialQueue 队列中以串行的方式执行。

添加任务

获取到队列之后，我们就可以向队列中添加任务。添加任务的方法如下：

• object-c

void dispatch_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);

void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

dispatch_sync 和 dispatch_async 函数 需要两个参数，一个是队列 queue，一个是需要添加的任务 block。它们的共同点是 block 都会在指定的队列 queue 上执行，无论 queue 是并行队列还是串行队列；不同的是 dispatch_sync 会阻塞当前线程，直到 block 结束，而 dispatch_async 不会阻塞当前线程。在做比较耗时的任务时，比如读取网络数据，就需要使用 dispatch_async 将任务异步的添加到另一个线程中处理。

例如：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  dispatch_async(queue, ^{
      // 完成任务

  });

• swift 3.0
  在 swift 中，使用 DispatchQueue 的下面的实例方法进行添加任务：

public func sync(execute workItem: DispatchWorkItem)
public func async(execute workItem: DispatchWorkItem)

例如：

let concurrentQueue = DispatchQueue.init(label: "concurrentQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .inherit, target: nil);
  concurrentQueue.async(execute: {
      //   
})

线程之间的切换

为了防止阻塞主线程，造成页面卡顿，影响交互，我们会将耗时的任务放到其他线程，等到任务结束时，再切换到主线程更新 UI，所以代码中经常会涉及到线程的切换。
例如：

• object-c

- (void)viewDidLoad {
  [super viewDidLoad];
  dispatch_queue_t queue =     dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  dispatch_async(queue, ^{
    // 完成耗时任务    
    
    dispatch_async(dispatch_get_main_queue(), ^{
      // 在主线程中更新 UI
    });
  });
}

• swift 3.0

override func viewDidLoad() {
    super.viewDidLoad()

    // 将耗时的任务放到其他线程
    DispatchQueue.global().async {
        // 完成耗时任务
        
        DispatchQueue.main.async {
            // 返回到主线程刷新 UI   
        }
    }
}

---

参考资料

细说GCD（Grand Central Dispatch）如何用