首先感谢行走的少年郎写的一篇文章《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 <NSThread: 0x610000069e80>{number = 1, name = main}
[915:40526] block1 <NSThread: 0x610000069e80>{number = 1, name = main}
[915:40526] block2 <NSThread: 0x610000069e80>{number = 1, name = main}
[915:40526] block2 <NSThread: 0x610000069e80>{number = 1, name = main}
[915:40526] block3 <NSThread: 0x610000069e80>{number = 1, name = main}
[915:40526] block3 <NSThread: 0x610000069e80>{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 <NSThread: 0x61800007a100>{number = 2, name = (null)}
[941:46686] block1 <NSThread: 0x61800007a100>{number = 2, name = (null)}
[941:46686] block2 <NSThread: 0x61800007a100>{number = 2, name = (null)}
[941:46686] block2 <NSThread: 0x61800007a100>{number = 2, name = (null)}
[941:46686] block3 <NSThread: 0x61800007a100>{number = 2, name = (null)}
[941:46686] block3 <NSThread: 0x61800007a100>{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 <NSThread: 0x60000006da80>{number = 1, name = main}
[1001:58076] block1 <NSThread: 0x60000006da80>{number = 1, name = main}
[1001:58076] block2 <NSThread: 0x60000006da80>{number = 1, name = main}
[1001:58076] block2 <NSThread: 0x60000006da80>{number = 1, name = main}
[1001:58076] block3 <NSThread: 0x60000006da80>{number = 1, name = main}
[1001:58076] block3 <NSThread: 0x60000006da80>{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 <NSThread: 0x610000067c00>{number = 4, name = (null)}
[1042:64618] block2 <NSThread: 0x608000067e80>{number = 3, name = (null)}
[1042:64640] block1 <NSThread: 0x610000067d00>{number = 2, name = (null)}
[1042:64615] block3 <NSThread: 0x610000067c00>{number = 4, name = (null)}
[1042:64618] block2 <NSThread: 0x608000067e80>{number = 3, name = (null)}
[1042:64640] block1 <NSThread: 0x610000067d00>{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 <NSThread: 0x6080000699c0>{number = 1, name = main}
[1097:77593] block1 <NSThread: 0x6080000699c0>{number = 1, name = main}
[1097:77593] block2 <NSThread: 0x6080000699c0>{number = 1, name = main}
[1097:77593] block2 <NSThread: 0x6080000699c0>{number = 1, name = main}
[1097:77593] block3 <NSThread: 0x6080000699c0>{number = 1, name = main}
[1097:77593] block3 <NSThread: 0x6080000699c0>{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 <NSThread: 0x60800006de40>{number = 1, name = main}
[1130:84261] block1 <NSThread: 0x60800006de40>{number = 1, name = main}
[1130:84261] block2 <NSThread: 0x60800006de40>{number = 1, name = main}
[1130:84261] block2 <NSThread: 0x60800006de40>{number = 1, name = main}
[1130:84261] block3 <NSThread: 0x60800006de40>{number = 1, name = main}
[1130:84261] block3 <NSThread: 0x60800006de40>{number = 1, name = main}
输出结果分析：
- 虽然是异步执行，可以开启新的线程，但因为是主队列，它只会在主线程中执行。（这点与普通串行队列有区别）
- 因为主队列是特殊的串行队列，所以队列的任务一个接一个地执行。
- 因为所有队列任务执行在
test start和test over之后，说明任务不是添加到队列之后立马执行，而是当所有任务添加到队列之后再执行。
</br>
�归纳注意事项：
（1）创建一个队列与创建一个线程是不同的两件事。
（2）在一个线程内可能会有多个队列，混杂有串行队列和并行队列。
（3）是否创建新线程，取决于队列是同步执行还是异步执行。
（4）死锁问题。
