iOS学习总结之GCD

作者: studyever | 来源:发表于2019-11-03 13:05 被阅读0次

iOS多线程：『GCD』详尽总结
iOS 开发之 GCD 不同场景使用
iOS 开发之 GCD 基础
iOS开发多线程之GCD
iOS开发之GCD并发队列
iOS开发之GCD同步任务加强
ios 中GCD总结
iOS学习总结之GCD
iOS开发之GCD串行队列
iOS 多线程学习-思维导图版本

什么是GCD

GCD(Grand Central Dispatch)是异步执行任务的技术之一，一般将应用程序中记述的线程管理用的代码在系统级实现，开发者只需要定义想执行的任务，并把任务追加到适当的分发队列(Dispatch Queue)中，GCD就能生成必要的线程并计划执行任务。

GCD的优点

GCD语法简单，使用Block回调，代码集中易懂，简化了多线程编程
因为线程管理是作为系统的一部分实现的，因此可以统一管理，也可执行任务，比之前的线程效率高（系统级线程管理）

GCD常见的API及其用法

Dispatch Queue
如名称所示，是执行处理的等待队列，Dispatch Queue把编程人员定义的想要执行的处理按照追加的顺序（FIFO，First-In-First-Out）执行处理。
Dispatch Queue有两种，一种是等待现在执行中处理的Serial Dispatch Queue u（串行队列），另一种是不等待现在执行的Concurrent Dispatch Queue（并行队列），以下展示两种队列的区别

- (void) testDispatchQueue {
// 串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.lemon.dipatch", DISPATCH_QUEUE_SERIAL);
// 并行队列
//    dispatch_queue_t queue = dispatch_queue_create("com.lemon.dispatch", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        sleep(2);
        NSLog(@"1");
    });
    dispatch_async(queue, ^{
        NSLog(@"2");
    });
    dispatch_async(queue, ^{
        NSLog(@"3");
    });
    dispatch_async(queue, ^{
        NSLog(@"4");
    });
    dispatch_async(queue, ^{
        NSLog(@"5");
    });
}

// 串行队列执行结果：
2019-01-01 14:53:28.483368+0800 TestBlock[68148:6421055] 1
2019-01-01 14:53:28.483502+0800 TestBlock[68148:6421055] 2
2019-01-01 14:53:28.483585+0800 TestBlock[68148:6421055] 3
2019-01-01 14:53:28.483664+0800 TestBlock[68148:6421055] 4
2019-01-01 14:53:28.483747+0800 TestBlock[68148:6421055] 5

// 并行队列执行结果：
2019-01-01 15:03:18.513884+0800 TestBlock[68263:6434398] 3
2019-01-01 15:03:18.513883+0800 TestBlock[68263:6434400] 2
2019-01-01 15:03:18.513896+0800 TestBlock[68263:6434396] 4
2019-01-01 15:03:18.513912+0800 TestBlock[68263:6434397] 5
2019-01-01 15:03:20.516357+0800 TestBlock[68263:6434399] 1

由以上结果可以看出，串行队列是按照顺序执行的，要等到现在的执行完成之后才能执行下一个，而并行队列是不用等待现在的执行处理结束，所以不管闪一个任务有没有结束，都开始执行下一个，但是并行处理的数量取决于当前系统的状态，当前的系统状态指的是iOS和OS X基于Dispatch Queue的处理数、CPU的核数及CPU负荷等。

dispatch_queue_create
通过dispatch_queue_create可以创建Dispatch Queue，生成Serial Dispatch Queue的代码如下所示

// 第一个参数指定线程的名称，名字应该简单易懂，方便调试，
dispatch_queue_t queue = dispatch_queue_create("com.lemon.dipatch", NULL)

虽然Serial Dispatch Queue和Concurrent Dispatch Queue 受到系统资源的限制，但用dispatch_queue_create 可以生成任意多个Dispatch Queue，如果过多使用多线程，会消耗大量的内存，引起大量的上下文切换，降低系统的响应性能
使用结束后需要dispatch_release进行释放

Main Dispatch Queue/Global Dispatch Queue
Main Dispatch Queue是在主线程中执行的，属于串行队列，与UI相关的操作需要放在主线程执行。
Global Dispatch Queue是所用应用程序都能使用的并行队列，有高（High）、低（Low）、默认（Default）、后台（Background）四个优先级，

dispatch_queue_category.jpg

获取系统的Dispatch Queue的方法如下

// get main queue
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    // high priority global queue
    dispatch_queue_t highGlobalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    // low priority global queue
    dispatch_queue_t lowGlobalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
    // default priority global queue
    dispatch_queue_t defaultGlobalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // backgroud priority global queue
    dispatch_queue_t backgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

dispatch_set_target_queue
dispatch_queue_create生成的Dispatch Queue，不管是并行队列还是串行队列，都是用与默认优先级Global Dispatch Queue相同执行优先级的线程，变更Dispatch Queue的优先级需要使用 dispatch_set_target_queue，举例如下：

// 当前队列
    dispatch_queue_t serialQueue = dispatch_queue_create("com.lemon.dispatch", NULL);
    // 目标队列
    dispatch_queue_t backgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
    // 第一个参数为要变更执行优先级的队列    第二个参数为要使用的优先级队列
    /*
     Dispatch Queue 把当前队列上的任务，分发到指定的目标队列执行。可以把多个队列上的任务分发到目标队列去执行，在保证执行效率的前提下减少线程数量，如果一个队列设置了目标分发队列，系统不会分配线程，除非目标线程是全局队列
     Dispatch sources  把对应的事件回调提交到目标队列去执行
     Dispatch I/O channels   在目标队列上执行I/O操作
*/
    dispatch_set_target_queue(serialQueue, backgroundQueue);

dispatch_after
想在特定时间之后执行处理的操作，可以用dispath_after 实现

 // 3秒之后将block追加到主线程
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        
    });

dispatch_after 函数并不是在指定的时间后执行处理，而是把处理追加到Dispatch Queue

dispatch_group
在追加到Dispatch Queue中的多个处理全部结束后再执行后续处理，可以使用dispatch_group，示例如下

dispatch_group_t groupQueue = dispatch_group_create();
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_async(groupQueue, globalQueue, ^{
        NSLog(@"execute job1");
    });
    dispatch_group_async(groupQueue, globalQueue, ^{
        NSLog(@"execute job2");
    });
    dispatch_group_async(groupQueue, globalQueue, ^{
        NSLog(@"execute job3");
    });
    dispatch_group_notify(groupQueue, dispatch_get_main_queue(), ^{
        NSLog(@"execute the job on main thread");
    });

执行结果如下：

2019-01-01 22:14:21.985148+0800 TestBlock[83010:6688021] execute job1
2019-01-01 22:14:21.985187+0800 TestBlock[83010:6688016] execute job3
2019-01-01 22:14:21.985263+0800 TestBlock[83010:6688022] execute job2
2019-11-01 22:14:22.001480+0800 TestBlock[83010:6687962] execute the job on main thread

因为Global Dispatch Queue是并行队列，所以追加处理的执行顺序不确定，但是在主线程执行的一定是在最后。

dispatch_barrier_async
在访问数据库或文件时，使用并行队列会有数据竞争的问题，写入处理不能与其他写入处理和包含读取处理的其他处理并行执行，而读处理可以并行执行，dispatch_barrier_async 即可实现这个目的。
例如有如下需求，前三个任务需要读取数据，第四个任务需要写入数据，而后两个任务需要第四个任务写入之后的数据，

__block NSString *ballName = @"basketball";
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(concurrentQueue, ^{
        NSLog(@"execute the reading job1");
        NSLog(@"The ball name is %@", ballName);
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"execute the reading job2");
        NSLog(@"The ball name is %@", ballName);
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"execute the reading job3");
        NSLog(@"The ball name is %@", ballName);
    });
    dispatch_barrier_async(concurrentQueue, ^{
        NSLog(@"execute the writing job4");
        ballName = @"football";
        NSLog(@"The ball name is %@", ballName);
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"execute the reading job5");
        NSLog(@"The ball name is %@", ballName);
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"execute the reading job6");
        NSLog(@"The ball name is %@", ballName);
    });

执行结果如下

2019-11-01 22:55:33.860155+0800 TestBlock[83120:6713619] execute the reading job1
2019-11-01 22:55:33.860173+0800 TestBlock[83120:6713620] execute the reading job2
2019-01-01 22:55:33.860192+0800 TestBlock[83120:6713617] execute the reading job3
2019-01-01 22:55:33.860211+0800 TestBlock[83120:6713618] execute the writing job4
2019-01-01 22:55:33.860287+0800 TestBlock[83120:6713619] The ball name is basketball
2019-01-01 22:55:33.860313+0800 TestBlock[83120:6713620] The ball name is basketball
2019-01-01 22:55:33.860329+0800 TestBlock[83120:6713617] The ball name is basketball
2019-01-01 22:55:33.860328+0800 TestBlock[83120:6713624] execute the reading job6
2019-01-01 22:55:33.860328+0800 TestBlock[83120:6713623] execute the reading job5
2019-01-01 22:55:33.860350+0800 TestBlock[83120:6713618] The ball name is football
2019-01-01 22:55:33.860679+0800 TestBlock[83120:6713624] The ball name is football
2019-01-01 22:55:33.861257+0800 TestBlock[83120:6713623] The ball name is football

dispatch_sync
dispatch_sync 表示同步，也就是将指定的block同步追加到指定的Dispatch Queue中，在追加的block结束之前，dispatch_sync 函数会一直等待，比如在执行Main Dispatch Queue时，使用另外的Global Dispatch Queue进行处理，处理结束后立即使用得到的结果，这种情况下就需要使用dispatch_sync

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_sync(globalQueue, ^{
        /*
         得到结果之后的处理
         */
    });

dispatch_sync使用简单，但是也容易出现死锁问题，比如以下代码

dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_sync(mainQueue, ^{
        NSLog(@"execute on main thread");
    });

dispatch_apply
dispatch_apply是dispatch_sync和dispatch_group的关联API，该函数按照指定的次数将指定的block追加到指定的Dispatch Queue中，并等待全部处理执行结束。

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_apply(5, globalQueue, ^(size_t index) {
        NSLog(@"%zu", index);
    });
    NSLog(@"dispatch_apply finished");
// 执行结果
2019-01-02 23:29:03.112894+0800 TestBlock[83409:6763722] 0
2019-01-02 23:29:03.113036+0800 TestBlock[83409:6763722] 1
2019-01-02 23:29:03.113074+0800 TestBlock[83409:6763786] 2
2019-01-02 23:29:03.113088+0800 TestBlock[83409:6763788] 3
2019-01-02 23:29:03.113095+0800 TestBlock[83409:6763785] 4
2019-01-02 23:29:03.113758+0800 TestBlock[83409:6763722] dispatch_apply finished

因为dispatch_apply与dispatch_sync都会等待处理执行结束，因此推荐在dispatch_async中非同步的使用dispatch_apply，示例如下

    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(globalQueue, ^{
        dispatch_apply(5, globalQueue, ^(size_t index) {
            NSLog(@"%zu", index);
            sleep(2);
        });
         NSLog(@"dispatch_apply finished");
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"update UI on main thread");
        });
    });
// 运行结果
2019-01-03 10:58:41.006055+0800 TestBlock[83587:6787137] 2
2019-01-03 10:58:41.006055+0800 TestBlock[83587:6787138] 1
2019-01-03 10:58:41.006055+0800 TestBlock[83587:6787139] 0
2019-01-03 10:58:41.006077+0800 TestBlock[83587:6787140] 3
2019-01-03 10:58:41.006099+0800 TestBlock[83587:6787143] 4
 dispatch_apply finished
2019-11-03 10:58:45.012906+0800 TestBlock[83587:6787077] update UI on main thread

dispatch_suspend和dispatch_resume
当追加大量的block到Dispatch Queue时，在追加处理的过程中，如果不希望执行已经追加的处理，调用dispatch_suspend 挂起当前队列即可，在需要恢复执行时，调用dispatch_resume 即可。
dispatch semaphore
当并行处理数据时，会产生数据不一致的情况，例如在对NSMutableArray非线程安全的对象操作时，很容易产生问题，如下面例子所示

    NSMutableArray *array =[[NSMutableArray alloc] init];
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    for (int i = 0; i < 1000; ++i) {
        dispatch_async(globalQueue, ^{
            [array addObject:[NSNumber numberWithInt:i]];
        });
    }
// 执行错误
TestBlock(83657,0x7000102a0000) malloc: *** error for object 0x7fbe02e0a9c0: pointer being freed was not allocated
TestBlock(83657,0x7000102a0000) malloc: *** set a breakpoint in malloc_error_break to debug

此时可以使用dispath_semaphore来控制，dispatch_semaphore采用计数信号，计数为0时等待，计数大于0时不等待，执行减1操作，用法如下

    NSMutableArray *array =[[NSMutableArray alloc] init];
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 创建信号量，并设置初始计数为1，表示一次只能一个线程执行
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    for (int i = 0; i < 1000; ++i) {
        // 第一个线程时，计数为1，所以可以执行，并将semaphore的计数减1，此时计数为0，其他的线程只能等待
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        [array addObject:[NSNumber numberWithInt:i]];
        // 执行结束时，将semaphore的计数加1，最先等待的线程此时就可以访问
        dispatch_semaphore_signal(semaphore);
    }
    NSLog(@"The count of array is: %zu", array.count);
// 执行结果
2019-01-03 11:43:21.040081+0800 TestBlock[83707:6813328] The count of array is: 1000

此时可以正常用行，dispatch_semaphore 是比Serial Dispatch Queue 和dispatch_barrier_async更小粒度的控制。

dispatch_once
dispatch_once是保证在应用程序中只运行一次指定处理的API，常用的用法如下

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // the code execute only once
    });

dispatch_once能保证在多线程的环境下也很安全，常用于单例模式。

总结

以上是GCD的概念和常用的API介绍，供大家参考，不足之处还请多多指教。

iOS多线程：『GCD』详尽总结
iOS多线程：『GCD』详尽总结 iOS多线程：『GCD』详尽总结
iOS 开发之 GCD 不同场景使用
iOS 开发之 GCD 不同场景使用本文在iOS 开发值 GCD 基础的基础上，继续总结了 GCD 的一些AP...
iOS 开发之 GCD 基础
iOS 开发之 GCD 基础本文主要为 GCD 的队列和执行方法等基础总结，目录如下: [TOC] GCD是什...
iOS开发多线程之GCD
iOS开发多线程之GCDiOS开发之GCD同步任务加强iOS开发之GCD串行队列iOS开发之GCD并发队列 GCD...
iOS开发之GCD并发队列
iOS开发多线程之GCDiOS开发之GCD同步任务加强iOS开发之GCD串行队列iOS开发之GCD并发队列 03 ...
iOS开发之GCD同步任务加强
iOS开发多线程之GCDiOS开发之GCD同步任务加强iOS开发之GCD串行队列iOS开发之GCD并发队列 004...
ios 中GCD总结
ios 中GCD总结
iOS学习总结之GCD
什么是GCD GCD(Grand Central Dispatch)是异步执行任务的技术之一，一般将应用程序中记述...
iOS开发之GCD串行队列
iOS开发多线程之GCDiOS开发之GCD同步任务加强iOS开发之GCD串行队列iOS开发之GCD并发队列实例d...
iOS 多线程学习-思维导图版本
GCD、NSOperation、NSThread 1.GCD 参考地址：iOS 多线程：『GCD』详尽总结重要概...

iOS学习总结之GCD

什么是GCD

GCD的优点

GCD常见的API及其用法

总结

相关文章

iOS多线程：『GCD』详尽总结

iOS 开发之 GCD 不同场景使用

iOS 开发之 GCD 基础

iOS开发多线程之GCD

iOS开发之GCD并发队列

iOS开发之GCD同步任务加强

ios 中GCD总结

iOS学习总结之GCD

iOS开发之GCD串行队列

iOS 多线程学习-思维导图版本

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读