GCD中涉及到两个十分重要的概念, 就是任务和队列
- 任务(Task): 你需要执行的操作
- 队列(Queue): 存放任务的容器
GCD中两个重要的函数, 一个同步执行, 一个异步执行
dispatch_async(dispatch_queue_t _Nonnull queue, ^(void)block)
dispatch_sync(dispatch_queue_t _Nonnull queue, ^(void)block)
这两个函数中均需要填入两个参数, 一个是队列, 一个是任务, 任务就是封装在block代码块中的. 所以, 我们在使用以上两个函数时, 只需要创建队列,将任务（block）添加进指定的队列中。并根据是否为sync决定调用该函数的线程是否需要阻塞。
注意:
这里调用该函数的线程并不执行参数中指定的任务（block块），任务的执行者是GCD分配给任务所在队列的线程。调用dispatch_sync和dispatch_async的线程，并不一定是任务（block块）的执行者。
同步执行和异步执行有什么区别呢?
同步执行：比如这里的dispatch_sync，这个函数会把一个block加入到指定的队列中，而且会一直等到执行完blcok，这个函数才返回。因此在block执行完之前，调用dispatch_sync方法的线程是阻塞的。
异步执行：一般使用dispatch_async，这个函数也会把一个block加入到指定的队列中，但是和同步执行不同的是，这个函数把block加入队列后不等block的执行就立刻返回了。
另外, 还有一点需要明确的是
- 同步执行没有开启新线程的能力, 所有的任务都只能在当前线程执行
- 异步执行有开启新线程的能力, 但是, 有开启新线程的能力, 也不一定会利用这种能力, 也就是说, 异步执行是否开启新线程, 需要具体问题具体分析
我们再来看看串行队列和并发队列
无论任何队列, 其实都遵循FIFO(first in first out, 先进先出原则)
串行队列可以保证在执行某个任务时，在它前面进入队列的所有任务肯定执行完了。对于每一个不同的串行队列，系统会为这个队列建立唯一的线程来执行代码。
但是并发队列它们的执行结束时间是不确定的，取决于每个任务的耗时。并发队列中的任务：GCD会动态分配多条线程来执行。具体几条线程取决于当前内存使用状况，线程池中线程数等因素。
清楚了以上概念,下面我们来根据他们的互相组合会发生什么,让我们拭目以待
1.同步执行+ 串行队列
- (void)syncSerial{
/* 1.创建一个串行队列 */
dispatch_queue_t serialQueue = dispatch_queue_create("download.zavier.com", DISPATCH_QUEUE_SERIAL);
/* 2.将任务放在队列中 */
dispatch_sync(serialQueue, ^{
NSLog(@"download1--------%@",[NSThread currentThread]);
});
dispatch_sync(serialQueue, ^{
NSLog(@"download2--------%@",[NSThread currentThread]);
});
dispatch_sync(serialQueue, ^{
NSLog(@"download3--------%@",[NSThread currentThread]);
});
}
执行情况:
download1--------<NSThread: 0x600003536cc0>{number = 1, name = main}
download2--------<NSThread: 0x600003536cc0>{number = 1, name = main}
download3--------<NSThread: 0x600003536cc0>{number = 1, name = main}
可以看出的是: 同步执行 + 串行队列没有开启新的线程, 所有的操作, 都是在当前线程执行.如果是在子线程中执行同步串行队列的操作, 当前的线程就是子线程,如下.
download1--------<NSThread: 0x600002e35b80>{number = 3, name = (null)}
执行完任务一
download2--------<NSThread: 0x600002e35b80>{number = 3, name = (null)}
执行完任务二
download3--------<NSThread: 0x600002e35b80>{number = 3, name = (null)}
执行完任务三
2.同步执行+ 并发队列
- (void)syncConcurrent{
/* 1.创建一个并发队列 */
dispatch_queue_t cuncurrentQueue = dispatch_queue_create("download.zavier.com", DISPATCH_QUEUE_CONCURRENT);
/* 2.将不同的任务添加到队列中 */
dispatch_sync(cuncurrentQueue, ^{
NSLog(@"download1--------%@",[NSThread currentThread]);
});
NSLog(@"执行完任务一");
dispatch_sync(cuncurrentQueue, ^{
NSLog(@"download2--------%@",[NSThread currentThread]);
});
NSLog(@"执行完任务二");
dispatch_sync(cuncurrentQueue, ^{
NSLog(@"download3--------%@",[NSThread currentThread]);
});
NSLog(@"执行完任务三");
}
执行情况:
download1--------<NSThread: 0x600000530640>{number = 1, name = main}
执行完任务一
download2--------<NSThread: 0x600000530640>{number = 1, name = main}
执行完任务二
download3--------<NSThread: 0x600000530640>{number = 1, name = main}
执行完任务三
可以看出的是:三个任务都在主线程中执行, 并没有开启新的线程. 但是, 是不是所有的同步执行的操作都在主线程中执行呢? 当然不是. 看下面的代码
- (void)syncConcurrentOnBackgroundThread {
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self syncConcurrent];
});
}
同理:我把同步执行+ 并发队列这个操作也放到子线程去执行, 那么执行的线程就是子线程
download1--------<NSThread: 0x600002e38d00>{number = 4, name = (null)}
执行完任务一
download2--------<NSThread: 0x600002e38d00>{number = 4, name = (null)}
执行完任务二
download3--------<NSThread: 0x600002e38d00>{number = 4, name = (null)}
执行完任务三
3.异步执行+ 串行队列
- (void)asyncSerial{
/* 1.创建一个串行队列 */
dispatch_queue_t serialQueue = dispatch_queue_create("download.zavier.com", DISPATCH_QUEUE_SERIAL);
/* 2.将不同的任务添加到队列中 */
dispatch_async(serialQueue, ^{
NSLog(@"download1--------%@",[NSThread currentThread]);
});
dispatch_async(serialQueue, ^{
NSLog(@"download2--------%@",[NSThread currentThread]);
});
dispatch_async(serialQueue, ^{
NSLog(@"download3--------%@",[NSThread currentThread]);
});
}
执行情况:
download1--------<NSThread: 0x60000202cb00>{number = 3, name = (null)}
download2--------<NSThread: 0x60000202cb00>{number = 3, name = (null)}
download3--------<NSThread: 0x60000202cb00>{number = 3, name = (null)}
可以看出的是: 异步执行 + 串行队列也开启了新的线程, 但是不管任务有多少个, 异步执行 + 同一条串行队列只开启一条新的线程, 任务的执行顺序也是按照队列中的顺序执行的, 因为同一条线程中, 必须等到前一个任务执行完毕后, 才能执行下一个任务.
4.异步执行+ 并发队列
- (void)asyncConcurrent{
/* 1.创建一个并发队列 */
dispatch_queue_t concurrentQueue = dispatch_queue_create("download.zavier.com", DISPATCH_QUEUE_CONCURRENT);
/* 2.将任务放到队列中, 下面的代码将三个任务放到队列中 */
dispatch_async(concurrentQueue, ^{
NSLog(@"download1-------%@",[NSThread currentThread]);
});
dispatch_async(concurrentQueue, ^{
NSLog(@"download2-------%@",[NSThread currentThread]);
});
dispatch_async(concurrentQueue, ^{
NSLog(@"download3-------%@",[NSThread currentThread]);
});
}
执行情况:
执行完任务一
download3-------<NSThread: 0x600003d420c0>{number = 5, name = (null)}
download2-------<NSThread: 0x600003d42000>{number = 4, name = (null)}
download1-------<NSThread: 0x600003d5b840>{number = 3, name = (null)}
可以看出的是:开启了不同的线程, 且,但是线程也不会无限开启,比如说你有100个任务,会开启100条线程吗?
除了以上这几类组合,还有两个概念,一个是全局并发队列和主队列
全局并发队列:就是我们常说的全局队列,它是一个并发队列, 它是系统为我们创建好的一个全局并发队列, 所以, 有时候, 我们不需要自己创建一个并发队列, 直接用系统为我们提供的全局队列就可以了,所以全局队列和同步执行以及异步执行的组合同并发队列是一样的
比较特殊的是主队列
主队列:系统会把主队列中的任务放在主线程中执行
5.异步执行+ 主队列
- (void)asyncMainQueue{
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"download1------%@",[NSThread currentThread]);
});
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"download2------%@",[NSThread currentThread]);
});
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"download3------%@",[NSThread currentThread]);
});
}
执行情况:
download1------<NSThread: 0x600001906780>{number = 1, name = main}
download2------<NSThread: 0x600001906780>{number = 1, name = main}
download3------<NSThread: 0x600001906780>{number = 1, name = main}
需要注意的是:异步执行虽然有开启新线程的能力, 但是
6.同步执行+ 主队列
- (void)syncMainQueue{
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"download1------%@",[NSThread currentThread]);
});
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"download2------%@",[NSThread currentThread]);
});
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"download3------%@",[NSThread currentThread]);
});
}
执行情况如下图:
直接奔溃,
关于死锁
1.概念
所谓死锁，通常指有两个线程T1和T2都卡住了，并等待对方完成某些操作。T1不能完成是因为它在等待T2完成。但T2也不能完成，因为它在等待T1完成。于是大家都完不成，就导致了死锁（DeadLock）
2.产生死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。
首先来看一份经典的死锁代码:
int main(int argc, const char * argv[]) {
@autoreleasepool {
dispatch_sync(dispatch_get_main_queue(), ^(void){
NSLog(@"这里死锁了");
});
}
return 0;
}
首先明确的是：执行这个dispatch_get_main_queue队列的是主线程。执行了dispatch_sync函数后，将block添加到了main_queue中，同时调用dispatch_sync这个函数的线程（也就是主线程）被阻塞，等待block执行完成，而执行主线程队列任务的线程正是主线程，此时他处于阻塞状态，所以block永远不会被执行，因此主线程一直处于阻塞状态。因此这段代码运行后，并非卡在block中无法返回，而是根本无法执行到这个block。
同理前面死锁的代码,可以这样理解:
执行syncMainQueue这个方法是在主线程中执行的, 你可以把它看做一个任务A, 这个任务A也是在主队列中的,那么代码执行到第179行的时候, 启动了任务B, 把任务B放进了主队列中, 由于是同步执行, 所以, 必须等待任务B执行完了之后才能继续向下执行, 但是主线程有任务A, 所以任务B无法放到主线程中去执行,任务B等待任务A执行, 任务A等待任务B执行, 这样就造成了死锁.
如图
但是,如果将同步执行+ 主队列的操作放到子线程中执行, 就不会造成死锁
- (void)syncMainOnBackgroundThread{
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self syncMainQueue];
});
}
执行情况:
download1------<NSThread: 0x600001c0df40>{number = 1, name = main}
download2------<NSThread: 0x600001c0df40>{number = 1, name = main}
download3------<NSThread: 0x600001c0df40>{number = 1, name = main}
那为什么同步执行 + 串行队列不会造成死锁呢?
- (void)syncSerial{
/* 1.创建一个串行队列 */
dispatch_queue_t serialQueue = dispatch_queue_create("download.zavier.com", DISPATCH_QUEUE_SERIAL);
/* 2.将任务放在队列中 */
dispatch_sync(serialQueue, ^{
NSLog(@"download1--------%@",[NSThread currentThread]);
});
dispatch_sync(serialQueue, ^{
NSLog(@"download2--------%@",[NSThread currentThread]);
});
dispatch_sync(serialQueue, ^{
NSLog(@"download3--------%@",[NSThread currentThread]);
});
}
执行结果:
download1--------<NSThread: 0x600003536cc0>{number = 1, name = main}
download2--------<NSThread: 0x600003536cc0>{number = 1, name = main}
download3--------<NSThread: 0x600003536cc0>{number = 1, name = main}
原因是:download.zavier.com这个队列的执行线程是主线程,同步执行不会开辟新线程,但这时候我们将任务添加到了download.zavier.com这个队列中,所以主线程会来立即执行这个队列中的任务，执行完成后就会返回，主线程不会继续被阻塞。所以不会死锁
事实上,导致死锁的原因一定是:
在某一个串行队列中，同步的向这个串行队列添加block。
说了这么多, 可能又有点晕, 其实这些应该在实际开发中慢慢体会, 碰到的情况多了, 自然而然就明白了. 现在, 我们只要记住下面的表格就可以了
各种队列的执行效果图:
