iOS 多线程之 GCD

GCD全称Grand Central Dispatch 。应用程序以Block块对象的形式提交任务到队列，GCD提供并管理的这些队列。 提交到GCD队列的工作在完全在系统管理的线程池上执行。
GCD 的一些常用方法：

Dispatch Queue

1. dispatch_get_main_queue

返回主线程，由系统创建，是一个串行队列。

2. dispatch_get_global_queue

 dispatch_get_global_queue(long identifier, unsigned long flags);

返回具有指定优先级的系统定义的全局并发队列。其中flags参数为保留位，供将来使用， 传递除零以外的任何值可能会导致 NULL返回值。
优先级分为四种：高、默认、低以及后台

#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

对应 Qos的优先级为：

dispatch_queue_priority_t	QoS
HIGH	NSQualityOfServiceUserInitiated
DEFAULT	NSQualityOfServiceDefault
LOW	NSQualityOfServiceUtility
BACKGROUND	NSQualityOfServiceBackground

• QOS_CLASS_USER_INTERACTIVE
  最高优先级，即使在争用情况下也可以运行几乎所有可用的系统CPU和I / O带宽。所以使用时应限于与用户的关键交互，例如处理主事件循环上的事件，视图绘制，动画等。
• QOS_CLASS_USER_INITIATED
  低于用户的关键交互，但相对高于系统上的其他工作，使用于持续时间短的操作
• QOS_CLASS_UTILITY
  用于一些可能需要花点时间的任务，这些任务不需要马上返回结果，比如下载任务等
• QOS_CLASS_BACKGROUND
  用于完全不紧急的任务，磁盘 I/O后台备份等用这个，使用此QOS类表明工作应以最节能和最有效的方式运行
• QOS_CLASS_DEFAULT
  优先级介于user-initiated 和 utility，由pthread_create（）创建的线程没有指定QOS的属性将默认为QOS_CLASS_DEFAULT， 此值不应用作工作分类，只应在传播或恢复系统提供的QOS类值时进行设置

3. dispatch_queue_create

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

其中label:队列名称，用于debug时唯一标示此队列，建议使用反向DNS命名样式（com.example.myqueue），因为应用程序、库和框架等都可以创建自己的队列
attr:DISPATCH_QUEUE_SERIAL or NULL为串行队列，DISPATCH_QUEUE_CONCURRENT为并行队列
iOS 8之后可以使用dispatch_queue_attr_make_with_qos_class方法来生成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)

relative_priority为相对优先级（相对于指定优先级的负偏移量，因为优先级qos_class实际就是一个 int的枚举），传递大于零或小于QOS_MIN_RELATIVE_PRIORITY（-15）的值会导致返回NULL；一般直接设置为0
还可以通过dispatch_set_target_queue设置优先级

dispatch_queue_t serialQueue = dispatch_queue_create("com.example.MyQueue",NULL);  
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);  
//serialQueue现在的优先级跟globalQueue的优先级一样
dispatch_set_target_queue(serialQueue, globalQueue);

这个方法的前提是线程创建时没有指定优先级，但是系统还是建议使用dispatch_queue_attr_make_with_qos_class来设置优先级
另外，dispatch_set_target_queue有一个属性，就是如果一个串行队列，他的目标队列是另一个串行队列，那么提交到这个串行队列的 block块不会与提交到目标队列或者具有相同目标队列的任何其他队列的block块同时调用，比较绕口，如下代码：

dispatch_queue_t targetQueue = dispatch_queue_create("com.yxw.target_queue", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue1 = dispatch_queue_create("com.yxw.queue1", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("com.yxw.queue2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_set_target_queue(queue1, targetQueue);
    dispatch_set_target_queue(queue2, targetQueue);
    dispatch_async(queue1, ^{
        NSLog(@"target do job1");
        [NSThread sleepForTimeInterval:5.f];
    });
    dispatch_async(queue2, ^{
        NSLog(@"target do job2");
        [NSThread sleepForTimeInterval:2.f];
    });
    dispatch_async(queue2, ^{
        NSLog(@"target do job3");
        [NSThread sleepForTimeInterval:1.f];
    });
    dispatch_async(targetQueue, ^{
        NSLog(@"target do job4");
        [NSThread sleepForTimeInterval:2.f];
    });

执行结果：

YMultiThreadDemo[4068:382944] target do job1
YMultiThreadDemo[4068:382944] target do job2
YMultiThreadDemo[4068:382944] target do job3
YMultiThreadDemo[4068:382944] target do job4

4. dispatch_barrier_async

dispatch_barrier_async用于等待队列前面的任务执行完毕后自己才执行，而它后面的任务也需等待它完成之后才执行。如数据的读写：

dispatch_queue_t dbQueue = dispatch_queue_create("com.yxw.database", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(dbQueue, ^{
        NSLog(@"DB reading data1");
        [NSThread sleepForTimeInterval:1.];
        NSLog(@"DB read data1 completed");
    });
    dispatch_async(dbQueue, ^{
        NSLog(@"DB reading data2");
        [NSThread sleepForTimeInterval:2.];
        NSLog(@"DB read data2 completed");
    });
    dispatch_barrier_async(dbQueue, ^{
        NSLog(@"DB writing data1");
        [NSThread sleepForTimeInterval:1.];
        NSLog(@"DB write data1 completed");
    });
    dispatch_async(dbQueue, ^{
        NSLog(@"DB reading data3");
        [NSThread sleepForTimeInterval:1.];
    });

执行结果：

YMultiThreadDemo[4239:399611] DB reading data1
YMultiThreadDemo[4239:399637] DB reading data2
YMultiThreadDemo[4239:399611] DB read data1 completed
YMultiThreadDemo[4239:399637] DB read data2 completed
YMultiThreadDemo[4239:399637] DB writing data1
YMultiThreadDemo[4239:399637] DB write data1 completed
YMultiThreadDemo[4239:399637] DB reading data3

5. dispatch_queue_set_specific 、dispatch_get_specific

dispatch_queue_set_specific(dispatch_queue_t queue, const void *key,
        void *_Nullable context, dispatch_function_t _Nullable destructor)
dispatch_queue_get_specific(dispatch_queue_t queue, const void *key)

dispatch_queue_set_specific用系统唯一的key将特定的上下文与queue关联，dispatch_queue_get_specific则是通过这个key返回关联的上下文，如：

dispatch_queue_set_specific(queue, kDispatchQueueSpecificKey, (__bridge void *)self, NULL);
YGCDViewController *wself =
    (__bridge id)dispatch_queue_get_specific(queue, kDispatchQueueSpecificKey);
    NSLog(@"get specific wself title %@",wself.navigationItem.title);

6. dispatch_apply

dispatch_apply(size_t iterations,
       dispatch_queue_t DISPATCH_APPLY_QUEUE_ARG_NULLABILITY queue,
       DISPATCH_NOESCAPE void (^block)(size_t))

dispatch_apply类似一个循环，在指定的queue中执行iterations后返回，如果指定的队列是并发的，则会同时调用block块，这样就要求block是可重入的

dispatch_apply(5, serialQueue, ^(size_t i) {
        NSLog(@"apply run %zi times",i);
});

执行结果：

YMultiThreadDemo[4961:481865] apply run 0 times
YMultiThreadDemo[4961:481865] apply run 1 times
YMultiThreadDemo[4961:481865] apply run 2 times
YMultiThreadDemo[4961:481865] apply run 3 times
YMultiThreadDemo[4961:481865] apply run 4 times

Dispatch Block

dispatch_block_create(dispatch_block_flags_t flags, dispatch_block_t block);

返回的块已经由Block_copy拷贝到堆中，返回块的第一次执行完成才会响应dispatch_block_wait()或者dispatch_block_notify()方法
flags参数：

• DISPATCH_BLOCK_BARRIER ，提交到并行队列时，这个标志相当于dispatch_barrier_async()
• DISPATCH_BLOCK_INHERIT_QOS_CLASS，异步提交到队列时默认使用
• DISPATCH_BLOCK_ENFORCE_QOS_CLASS，同步提交到队列时默认使用

1. dispatch_block_wait 与 dispatch_block_notify

dispatch_block_wait(dispatch_block_t block, dispatch_time_t timeout)
dispatch_block_notify(dispatch_block_t block, dispatch_queue_t queue,
        dispatch_block_t notification_block)

dispatch_block_wait：等待指定的block块执行完，或者指定的timeout已经超出，这个方法会阻塞当前线程，所以不要放在主线程中，另外，用dispatch_block_cancel方法取消的 block也算执行完成
dispatch_block_notify:功能跟上面方法类似，等待指定的block块执行完，然后在queue中执行notification_block

2. dispatch_block_cancel

iOS 8 之后，可以通过dispatch_block_cancel方法取消待执行的block,已经在执行的block没有影响，与取消block相关联的任何资源将被延迟释放，直到下一次尝试执行该block
上面三个方法的代码如下：

    dispatch_queue_t queue = dispatch_queue_create("com.yxw.queue", DISPATCH_QUEUE_SERIAL);
    dispatch_block_t block = dispatch_block_create(0, ^{
        NSLog(@"before block sleep");
        [NSThread sleepForTimeInterval:2.];
        NSLog(@"after block sleep");
    });
    dispatch_block_t block2 = dispatch_block_create(0, ^{
        NSLog(@"before block2 sleep");
        [NSThread sleepForTimeInterval:10.];
        NSLog(@"after block2 sleep");
    });
    dispatch_async(queue, block);
    dispatch_async(queue, block2);
    
    dispatch_async(globalQueue, ^{
        //等待block执行完毕
        dispatch_block_wait(block, DISPATCH_TIME_FOREVER);
        NSLog(@"block wait coutinue");
    });
    dispatch_block_notify(block, globalQueue, ^{
         NSLog(@"block notify coutinue");
    });
    
    dispatch_async(globalQueue, ^{
        [NSThread sleepForTimeInterval:0.5];
        dispatch_block_cancel(block2);
        dispatch_block_cancel(block);
    });
    
    dispatch_block_notify(block2, globalQueue, ^{
        NSLog(@"block2 notify coutinue");
    });

执行结果如下：

YMultiThreadDemo[2690:227780] before block sleep
YMultiThreadDemo[2690:227780] after block sleep
YMultiThreadDemo[2690:227780] block notify coutinue
YMultiThreadDemo[2690:227959] block wait coutinue
YMultiThreadDemo[2690:227962] block2 notify coutinue

可以看到，block2取消成功，block2的notify执行了，block取消无效
下面的代码测试只有block的第一次执行完成才会notify：

    dispatch_block_t block3 = dispatch_block_create(0, ^{
        NSLog(@"before block3 sleep");
        [NSThread sleepForTimeInterval:1.];
        NSLog(@"after block3 sleep");
    });
    dispatch_async(globalQueue, block3);
    dispatch_block_notify(block3, globalQueue, ^{
        NSLog(@"block3 notify coutinue");
    });
    dispatch_async(globalQueue, ^{
        [NSThread sleepForTimeInterval:3.];
        block3();
    });

执行结果：

YMultiThreadDemo[4569:356960] before block3 sleep
YMultiThreadDemo[4569:356960] after block3 sleep
YMultiThreadDemo[4569:356960] block3 notify coutinue
YMultiThreadDemo[4569:356961] before block3 sleep
YMultiThreadDemo[4569:356961] after block3 sleep

Dispatch Group

当我们想在gcd queue中所有的任务执行完毕之后做些特定事情的时候，也就是队列的同步问题，如果队列是串行的话，那将该操作最后添加到队列中即可，但如果队列是并行队列的话，这时候就可以利用dispatch_group来实现了，dispatch_group能很方便的解决同步的问题。dispatch_group_create可以创建一个group对象，然后可以添加block到该组里面，下面看下它的一些用法：

1. dispatch_group_wait 与 dispatch_group_notify

跟上面的dispatch_block_wait 、 dispatch_block_notify类似，但这里是等待前面提交到group的block执行完
代码如下：

    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group,globalQueue,^{ NSLog(@"group block1"); });
    dispatch_group_async(group,globalQueue,^{ NSLog(@"group block2"); });
    dispatch_async(globalQueue, ^{
        dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
        NSLog(@"group wait done");
    });
    dispatch_group_notify(group, globalQueue, ^{
        NSLog(@"group notify done");
    });

执行结果：

YMultiThreadDemo[4877:387857] group block1
YMultiThreadDemo[4877:387857] group block2
YMultiThreadDemo[4877:387857] group wait done
YMultiThreadDemo[4877:387858] group notify done

2. dispatch_group_enter 与 dispatch_group_leave

假如我们不想使用dispatch_group_async异步的将任务丢到group中去执行，这时候就需要用到dispatch_group_enter跟dispatch_group_leave方法，这两个方法要配对出现，以下这两种方法是等价的：

dispatch_group_async(group, queue, ^{ 
}); 

dispatch_group_enter(group);
dispatch_async(queue, ^{
　　dispatch_group_leave(group);
});

dispatch_once

dispatch_once(dispatch_once_t *predicate,
        DISPATCH_NOESCAPE dispatch_block_t block);

在 APP 生命周期内，保证只执行一次。一般用于单例的初始化。如果从多个线程同时调用，则此函数将同步等待，所以能保证唯一单例。
predicate与dispatch_once一起使用的谓词。 它必须初始化为零，而且必须是静态或全局变量。因为dispatch_once_t实际就是long类型，所以传进去的是指向dispatch_once_t的指针，用于表示block块是否已完成（执行完predicate为-1）。
如下：

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
    });
    NSLog(@"onceToken %zi",onceToken);

执行完后onceToken为-1，表示执行完，下次调用就不会再执行block块了。

参考文献
https://developer.apple.com/documentation/dispatch?language=objc