iOS-GCD使用详解

前前言
本文绝大部分内容来自
https://www.cnblogs.com/allencelee/p/6023213.html
此文章是学习此文章后的新的相关结果.
[]是修改/添加的内容
代码和打印结果都改了一下.

Mac环境:
macOS High Sierra 10.13.4
Xcode9.2
手机:
iOS11.1.2 iPhone6s

前言
对初学者来说，GCD似乎是一道迈不过去的坎，很多人在同步、异步、串行、并行和死锁这几个名词的漩涡中渐渐放弃治疗。本文将使用图文表并茂的方式给大家形象地解释其中的原理和规律。

线程、任务和队列的概念

image

异步、同步 & 并行、串行的特点

image

[添加]

同步执行一定是在当前线程,无论是在并行队列还是在串行队列!
异步执行是具备开启新线程,但是不一定100%开启新线程,如果有线程空余就直接拿来用!

一条重要的准则

一般来说，我们使用GCD的最大目的是在新的线程中同时执行多个任务，这意味着我们需要两项条件：
1.能开启新的线程
2.任务可以同时执行

结合以上两个条件，也就等价“开启新线程的能力 + 任务同步执行的权利”，只有在满足能力与权利这两个条件的前提下，我们才可以在同时执行多个任务。

所有组合的特点([添加]在主线程和主队列执行的情况下)

在主线程和主队列执行的情况下

（一）异步执行 + 并行队列
实现代码：

// 异步执行 + 并行队列
- (void)asyncConcurrent {
    printf("\n================%s================\n", [NSStringFromSelector(_cmd) UTF8String]);
    printf("main: %s\n", [[[NSThread mainThread] description] UTF8String]);
    //创建一个并行队列
    dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);
    printf("---start---\n");
    //使用异步函数封装三个任务
    dispatch_async(queue, ^{
        printf("任务1---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_async(queue, ^{
        printf("任务2---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_async(queue, ^{
        printf("任务3---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    // 这一段代码可以证明end输出的顺序不确定,主要是看哪个先执行完毕
//    sleep(1);
    printf("---end---\n");
}

打印结果:

================asyncConcurrent================
main: {number = 1, name = main}
---start---
---end---
任务1---{number = 4, name = (null)}
任务3---{number = 4, name = (null)}
任务2---{number = 3, name = (null)}

解释
异步执行意味着

  可以开启新的线程
  任务可以先绕过不执行，回头再来执行

并行队列意味着

   任务之间不需要排队，且具有同时被执行的“权利”

两者组合后的结果

开了三个新线程
函数在执行时，先打印了start和end，再回头执行这三个任务
[修改]这三个任务是同时执行的，没有先后，所以打印结果是随机的,
关于开线程有可能是开启1个,2个,3个,这个是随机的,
这个可以重复的运行几次,每次的结果都不一定一致.
end与任务1,2,3 输出的顺序不一定

步骤图

image

（二）异步执行 + 串行队列
实现代码：

// 异步执行 + 串行队列
- (void)asyncSerial {
    printf("\n================%s================\n", [NSStringFromSelector(_cmd) UTF8String]);
    printf("main: %s\n", [[[NSThread mainThread] description] UTF8String]);
    //创建一个串行队列
    dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_SERIAL);
    printf("---start---\n");
    //使用异步函数封装三个任务
    dispatch_async(queue, ^{
        printf("任务1---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_async(queue, ^{
        printf("任务2---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_async(queue, ^{
        printf("任务3---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    printf("---end---\n");
}

打印结果:

================asyncSerial================
main: {number = 1, name = main}
---start---
---end---
任务1---{number = 3, name = (null)}
任务2---{number = 3, name = (null)}
任务3---{number = 3, name = (null)}

解释
异步执行意味着

可以开启新的线程
任务可以先绕过不执行，回头再来执行

串行队列意味着

任务必须按添加进队列的顺序挨个执行

两者组合后的结果

开了一个新的子线程
函数在执行时，先打印了start和end，再回头执行这三个任务
这三个任务是按顺序执行的，所以打印结果是“任务1-->任务2-->任务3”

步骤图

image

（三）同步执行 + 并行队列
实现代码：

// 同步执行 + 并行队列
- (void)syncConcurrent {
    printf("\n================%s================\n", [NSStringFromSelector(_cmd) UTF8String]);
    printf("main: %s\n", [[[NSThread mainThread] description] UTF8String]);
    //创建一个并行队列
    dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);
    
    printf("---start---\n");
    //使用同步函数封装三个任务
    dispatch_sync(queue, ^{
        printf("任务1---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_sync(queue, ^{
        printf("任务2---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_sync(queue, ^{
        printf("任务3---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    printf("---end---\n");
}

打印结果：

================syncConcurrent================
main: {number = 1, name = main}
---start---
任务1---{number = 1, name = main}
任务2---{number = 1, name = main}
任务3---{number = 1, name = main}
---end---

解释
同步执行执行意味着

不能开启新的线程
任务创建后必须执行完才能往下走

并行队列意味着

任务必须按添加进队列的顺序挨个执行

两者组合后的结果

所有任务都只能在主线程中执行
函数在执行时，必须按照代码的书写顺序一行一行地执行完才能继续

注意事项

在这里即便是并行队列，任务可以同时执行，
但是由于只存在一个主线程，所以没法把任务分发到不同的线程去同步处理，
其结果就是只能在主线程里按顺序挨个挨个执行了

步骤图

image

（四）同步执行+ 串行队列
实现代码：

// 同步执行 + 串行队列
- (void)syncSerial{
    printf("\n================%s================\n", [NSStringFromSelector(_cmd) UTF8String]);
    printf("main: %s\n", [[[NSThread mainThread] description] UTF8String]);
    //创建一个串行队列
    dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_SERIAL);
    
    printf("---start---\n");
    //使用异步函数封装三个任务
    dispatch_sync(queue, ^{
        printf("任务1---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_sync(queue, ^{
        printf("任务2---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_sync(queue, ^{
        printf("任务3---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    printf("---end---\n");
}

打印结果:

================syncSerial================
main: {number = 1, name = main}
---start---
任务1---{number = 1, name = main}
任务2---{number = 1, name = main}
任务3---{number = 1, name = main}
---end---

解释

这里的执行原理和步骤图跟“同步执行+并发队列”是一样的，
只要是同步执行就没法开启新的线程，所以多个任务之间也一样只能按顺序来执行，

（五）异步执行+主队列
实现代码：

// 异步执行 + 主队列
- (void)asyncMain {
    printf("\n================%s================\n", [NSStringFromSelector(_cmd) UTF8String]);
    printf("main: %s\n", [[[NSThread mainThread] description] UTF8String]);
    //获取主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    printf("---start---\n");
    //使用异步函数封装三个任务
    dispatch_async(queue, ^{
        printf("任务1---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_async(queue, ^{
        printf("任务2---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_async(queue, ^{
        printf("任务3---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    printf("---end---\n");
}

打印结果:

================asyncMain================
main: {number = 1, name = main}
---start---
---end---
任务1---{number = 1, name = main}
任务2---{number = 1, name = main}
任务3---{number = 1, name = main}

解释
异步执行意味着

可以开启新的线程
任务可以先绕过不执行，回头再来执行

主队列跟串行队列的区别

队列中的任务一样要按顺序执行
主队列中的任务必须在主线程中执行，不允许在子线程中执行

以上条件组合后得出结果：

所有任务都可以先跳过，之后再来“按顺序”执行

步骤图

image

（六）同步执行+主队列（死锁）
实现代码：

// 同步执行 + 主队列
- (void)syncMain {
    printf("\n================%s================\n", [NSStringFromSelector(_cmd) UTF8String]);
    printf("main: %s\n", [[[NSThread mainThread] description] UTF8String]);
    //获取主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    printf("---start---\n");
    //使用同步函数封装三个任务
    dispatch_sync(queue, ^{
        printf("任务1---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_sync(queue, ^{
        printf("任务2---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    dispatch_sync(queue, ^{
        printf("任务3---%s\n", [[[NSThread currentThread] description] UTF8String]);
    });
    printf("---end---\n");
}

执行结果:

================syncMain================
main: {number = 1, name = main}
---start---

[添加]程序会直接崩溃(看来苹果已经能直接发现这个死锁)
解释

主队列中的任务必须按顺序挨个执行
任务1要等主线程有空的时候（即主队列中的所有任务执行完）才能执行
主线程要执行完“打印end”的任务后才有空
"任务1"和"打印end"两个任务互相等待，造成死锁

步骤图

image

[以下都是添加的]
以上代码都是在主线程执行的,关于第六段代码,可以用如下的代码测试.syn

// 同步执行 + 一个串行队列, 类似于同步执行 + 主队列
- (void)syncSerialInSerial {
    printf("\n================%s================\n", [NSStringFromSelector(_cmd) UTF8String]);
    printf("main: %s\n", [[[NSThread mainThread] description] UTF8String]);
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    printf("---main start---\n");
    // 这里使用 dispatch_sync 也会导致死锁
    dispatch_async(queue, ^{
        printf("---queue start---\n");
        printf("queue start(用dispatch_sync是主线程,用dispatch_async会开启一个线程)---%s\n", [[[NSThread currentThread] description] UTF8String]);
        //使用同步函数封装三个任务
        dispatch_sync(queue, ^{
            printf("任务1---%s\n", [[[NSThread currentThread] description] UTF8String]);
        });
        dispatch_sync(queue, ^{
            printf("任务2---%s\n", [[[NSThread currentThread] description] UTF8String]);
        });
        dispatch_sync(queue, ^{
            printf("任务3---%s\n", [[[NSThread currentThread] description] UTF8String]);
        });
        printf("---queue end---\n");
    });
    printf("---当最外面是dispatch_async输出,如果是dispatch_sync不输出---\n");
    printf("---main end---\n");
}

打印结果:

================syncSerialInSerial================
main: {number = 1, name = main}
---main start---
---queue start---
queue start---{number = 1, name = main}

上面的程序也会崩溃.

关于gcd的更多死锁可以看
http://www.knowsky.com/884482.html

GCD实现多读单写:

.h文件

@interface RXMRSWPerson : NSObject
// 当同时设置set和get的时候,不会自动生成_name变量
@property (nonatomic, copy) NSString *name;
@end

.m文件

@interface RXMRSWPerson() {
    @private
    NSString *_name;
}
@property (nonatomic, strong) dispatch_queue_t queue;
@end

@implementation RXMRSWPerson

- (id)init {
    if (self = [super init]) {
        _name = @"";
    }
    return self;
}
- (dispatch_queue_t)queue {
    if (_queue == nil) {
        _queue = dispatch_queue_create("com.rxmrswperson.com", DISPATCH_QUEUE_CONCURRENT);
    }
    return _queue;
}


- (void)setName:(NSString *)name {
    dispatch_barrier_async(self.queue, ^{
        _name = name;
    });
}

- (NSString *)name {
    __block NSString *tmpName;
    dispatch_sync(self.queue, ^{
        tmpName = _name;
    });
    return tmpName;
}

测试?

- (void)testPerson {
    RXMRSWPerson *person = [RXMRSWPerson new];
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);
    dispatch_queue_t serialQueue = dispatch_queue_create("com.serail.queue", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t concurrentQueue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
    
    person.name = @"init";
    dispatch_async(mainQueue, ^{
        NSLog(@"person name in mainQueue:%@", person.name);
    });
    dispatch_async(globalQueue, ^{
        NSLog(@"person name in globalQueue:%@", person.name);
        person.name = @"globalQueue";
    });
    dispatch_async(serialQueue, ^{
        person.name = @"serialQueue";
        NSLog(@"person name in serialQueue:%@", person.name);
    });
    dispatch_async(concurrentQueue, ^{
        person.name = @"concurrentQueue";
    });
    
    NSLog(@"person name:%@", person.name);
    
}

判断当前执行队列是否是某个队列

- (BOOL)isCurQueueEqualQueue:(dispatch_queue_t)queue {
    NSString *specificKey = @"com.specific.specificKey";
    NSString *specificValue = [NSString stringWithFormat:@"com.specific.sepcificValue.%@", [NSDate new]];
    dispatch_queue_set_specific(queue, &specificKey, (__bridge void *)specificValue, NULL);
    NSString *retrievedValue = (__bridge NSString *)dispatch_get_specific(&specificKey);
    return [retrievedValue isEqualToString:specificValue];
}

dispatch_queue_set_specific 、dispatch_get_specific

这两个API类似于objc_setAssociatedObject跟objc_getAssociatedObject，  

Target Queue的例子:

https://blog.csdn.net/growinggiant/article/details/41077221

/**
 下边来看更有意思的，一般都是把一个任务放到一个串行的queue中，如果这个任务被拆分了，被放置到多个串行的queue中，但实际还是需要这个任务同步执行，那么就会有问题，因为多个串行queue之间是并行的。
 那该如何是好呢？
 这是就可以使用dispatch_set_target_queue了。
 如果将多个串行的queue使用dispatch_set_target_queue指定到了同一目标，那么着多个串行queue在目标queue上就是同步执行的，不再是并行执行。
 */
- (void)testTargetQueue {
    dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_SERIAL);
//    dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t queue1 = dispatch_queue_create("test.1", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("test.2", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue3 = dispatch_queue_create("test.3", DISPATCH_QUEUE_SERIAL);
    
    dispatch_set_target_queue(queue1, targetQueue);
    dispatch_set_target_queue(queue2, targetQueue);
    dispatch_set_target_queue(queue3, targetQueue);
    
    
    dispatch_async(queue1, ^{
        NSLog(@"1 in");
        [NSThread sleepForTimeInterval:3.f];
        NSLog(@"1 out");
    });
    
    dispatch_async(queue1, ^{
        NSLog(@"4 in");
        [NSThread sleepForTimeInterval:3.f];
        NSLog(@"4 out");
    });
    
    dispatch_async(queue2, ^{
        NSLog(@"2 in");
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"2 out");
    });
    dispatch_async(queue3, ^{
        NSLog(@"3 in");
        [NSThread sleepForTimeInterval:1.f];
        NSLog(@"3 out");
    });
    
    
}