首先感谢行走的少年郎写的一篇文章《iOS多线程--彻底学会多线程之『GCD』》
它让我对GCD的许多概念有了清晰的理解。现在打算自己再亲自写一份笔记，以助加深印象。

1、队列

只有2种�队列：

Serial Dispatch Queue（串行队列）：等待正在执行中的处理结束，再执行下一条处理。
Concurrent Dispatch Queue（并发队列）：不等待现在执行中的处理是否结束，继续执行下面的处理。只有在异步执行中，才能体现并发性
�

创建串行队列：

dispatch_queue_t serialQueue = dispatch_queue_create("自定义署名", NULL);
//或
dispatch_queue_t serialQueue = dispatch_queue_create("自定义署名", DISPATCH_QUQUE_SERIAL);

创建并发队列：

dispatch_queue_t concurrentQueue = dispatch_queue_create("自定义署名", DISPATCH_QUQUE_CONCURRENT);

2、任务

只有2种执行任务的方式：

同步执行。不开启新的线程
异步执行。开启新的线程

同步执行：

dispatch_sync(queue, ^{  ...  });

异步执行：

dispatch_async(queue, ^{ ... });

还有一点区别就是：
同步队列是把一个任务添加到队列后立马就执行；而并发队列不会。
这会在4、GCD的具体使用中得到体现。

3、使用GCD就是队列+任务

串行队列+同步执行
串行队列+异步执行
并发队列+同步执行
并发队列+异步执行
主队列+同步执行
主队列+异步执行

补充说明：主队列属于串行队列，但因其特殊性单独列出来。

4、GCD的具体使用

（1）串行队列+同步执行

- (void) KSserialQueueSync {
    NSLog(@"test start");
    
    dispatch_queue_t serialQueue = dispatch_queue_create("com.ks.serialQueue", NULL);
    
    dispatch_sync(serialQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block1 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_sync(serialQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block2 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_sync(serialQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block3 %@", [NSThread currentThread]);
        }
    });
    
    NSLog(@"test over");
}

[915:40526] test start
[915:40526] block1 {number = 1, name = main}
[915:40526] block1 {number = 1, name = main}
[915:40526] block2 {number = 1, name = main}
[915:40526] block2 {number = 1, name = main}
[915:40526] block3 {number = 1, name = main}
[915:40526] block3 {number = 1, name = main}
[915:40526] test over

输出结果分析：

因为是同步执行，所以不创建新的线程，在主线程中执行。
因为是串行队列，所以队列的任务一个接一个地执行。
因为所有任务都在test start和test over之间执行，所以说明任务一加入队列就立马执行。

（2）串行队列+异步执行

- (void)KSserialQueueAsync {
    NSLog(@"test start");
    
    dispatch_queue_t serialQueue = dispatch_queue_create("com.ks.serialQueue", NULL);
    
    dispatch_async(serialQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block1 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_async(serialQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block2 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_async(serialQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block3 %@", [NSThread currentThread]);
        }
    });
    
    NSLog(@"test over");
}

[941:46623] test start
[941:46623] test over
[941:46686] block1 {number = 2, name = (null)}
[941:46686] block1 {number = 2, name = (null)}
[941:46686] block2 {number = 2, name = (null)}
[941:46686] block2 {number = 2, name = (null)}
[941:46686] block3 {number = 2, name = (null)}
[941:46686] block3 {number = 2, name = (null)}

输出结果分析：

因为是异步执行，所以创建了新的线程。
因为是串行队列，所以队列中的任务一个接一个执行。
因为所有队列任务执行在test start和test over之后，说明任务不是添加到队列之后立马执行，而是当所有任务添加到队列之后再执行。

（3）并发队列+同步执行

- (void)KSconcurrentQueueSync {
    NSLog(@"test start");
    
    dispatch_queue_t concurrentQueue = dispatch_queue_create("com.ks.concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_sync(concurrentQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block1 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_sync(concurrentQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block2 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_sync(concurrentQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block3 %@", [NSThread currentThread]);
        }
    });
    
    NSLog(@"test over");
}

[1001:58076] test start
[1001:58076] block1 {number = 1, name = main}
[1001:58076] block1 {number = 1, name = main}
[1001:58076] block2 {number = 1, name = main}
[1001:58076] block2 {number = 1, name = main}
[1001:58076] block3 {number = 1, name = main}
[1001:58076] block3 {number = 1, name = main}
[1001:58076] test over

输出结果分析：

因为是同步执行，不创建新的线程，在主线程中执行。
虽然是并发队列，但因为是同步执行，没有体现出并发性，任务还是一个接一个执行。
因为所有任务都在test start和test over之间执行，所以说明任务一加入队列就立马执行。

（4）并发队列+异步执行

- (void)KSconcurrentQueueAsync {
    NSLog(@"test start");
    
    dispatch_queue_t concurrentQueue = dispatch_queue_create("com.ks.concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block1 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block2 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block3 %@", [NSThread currentThread]);
        }
    });
    
    NSLog(@"test over");
}

[1042:64557] test start
[1042:64557] test over
[1042:64615] block3 {number = 4, name = (null)}
[1042:64618] block2 {number = 3, name = (null)}
[1042:64640] block1 {number = 2, name = (null)}
[1042:64615] block3 {number = 4, name = (null)}
[1042:64618] block2 {number = 3, name = (null)}
[1042:64640] block1 {number = 2, name = (null)}

输出结果分析：

因为异步执行，所以创建了新的线程。
因为并发队列，异步执行时体现其并发性，任务之间交替着同时执行。
因为所有队列任务执行在test start和test over之后，说明任务不是添加到队列之后立马执行，而是当所有任务添加到队列之后再执行。

（5）主队列+同步执行

- (void)KSmainQueueSync {
    NSLog(@"test start");
    
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    
    dispatch_sync(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block1 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_sync(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block2 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_sync(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block3 %@", [NSThread currentThread]);
        }
    });
    
    NSLog(@"test over");
}

[1084:70872] test start

输出结果分析：

只输出了一条语句，之后的语句都没有执行。
主队列是主线程的一条队列。
发生死锁：我们知道同步执行，就是要立马执行（参见串行队列同步执行和并发队列同步执行的结果分析第三条）。但是现在主队列无法立马执行，因为当前主线程正在执行的任务是KSmainQueueSync这个方法，需要等待这个方法执行完；但是KSmainQueueSync这个方法又要等待第一个第二个第三个任务执行完。相互等待而造成死锁。

只要在另一条线程上调用就好了，利用串行队列+异步执行来创建一条新的线程

dispatch_queue_t queue = dispatch_queue_create("com.ks.serialQueue", NULL);
    
dispatch_async(queue, ^{
        [self KSmainQueueSync];
});

[1097:77638] test start
[1097:77593] block1 {number = 1, name = main}
[1097:77593] block1 {number = 1, name = main}
[1097:77593] block2 {number = 1, name = main}
[1097:77593] block2 {number = 1, name = main}
[1097:77593] block3 {number = 1, name = main}
[1097:77593] block3 {number = 1, name = main}
[1097:77638] test over

输出结果分析：主队列是串行队列的一种，所以之前对串行队列的分析这里也适用

因为是同步执行，所以不创建新的线程，在主线程中执行。
因为是串行队列，所以队列的任务一个接一个地执行。
因为所有任务都在test start和test over之间执行，所以说明任务一加入队列就立马执行。

（6）主队列+异步执行

- (void)KSmainQueueAsync {
    NSLog(@"test start");
    
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    
    dispatch_async(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block1 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_async(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block2 %@", [NSThread currentThread]);
        }
    });
    
    dispatch_async(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"block3 %@", [NSThread currentThread]);
        }
    });
    
    NSLog(@"test over");
}

[1130:84261] test start
[1130:84261] test over
[1130:84261] block1 {number = 1, name = main}
[1130:84261] block1 {number = 1, name = main}
[1130:84261] block2 {number = 1, name = main}
[1130:84261] block2 {number = 1, name = main}
[1130:84261] block3 {number = 1, name = main}
[1130:84261] block3 {number = 1, name = main}

输出结果分析：

虽然是异步执行，可以开启新的线程，但因为是主队列，它只会在主线程中执行。（这点与普通串行队列有区别）
因为主队列是特殊的串行队列，所以队列的任务一个接一个地执行。
因为所有队列任务执行在test start和test over之后，说明任务不是添加到队列之后立马执行，而是当所有任务添加到队列之后再执行。

�归纳注意事项：
（1）创建一个队列与创建一个线程是不同的两件事。
（2）在一个线程内可能会有多个队列，混杂有串行队列和并行队列。
（3）是否创建新线程，取决于队列是同步执行还是异步执行。
（4）死锁问题。

GCD的Dispatch Queue（串行队列、并发队列、主队列）

1、队列

2、任务

3、使用GCD就是队列+任务

4、GCD的具体使用

（1）串行队列+同步执行

（2）串行队列+异步执行

（3）并发队列+同步执行

（4）并发队列+异步执行

（5）主队列+同步执行

（6）主队列+异步执行

你可能感兴趣的:(GCD的Dispatch Queue（串行队列、并发队列、主队列）)